bool VertexArray::isVertexEqual(Int32 index1, Int32 index2)
{
char* v1 = &_data[0] + getVertexSize() * index1;
char* v2 = &_data[0] + getVertexSize() * index2;
if(memcmp(v1,v2, getVertexSize()) == 0)
{
return true;
}
else
return false;
}
VertexBuffer *DX10Render::createVertexBuffer(int vertexCount, int vertexType, void *data, bool access)
{
DX10VertexBuffer *result = new DX10VertexBuffer();
D3D10_BUFFER_DESC bufferDesc;
bufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bufferDesc.ByteWidth = getVertexSize(vertexType) * vertexCount;
bufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.Usage = D3D10_USAGE_DYNAMIC;
D3D10_SUBRESOURCE_DATA initData;
initData.pSysMem = data;
HRESULT hr = device->CreateBuffer(&bufferDesc, &initData, &result->buffer);
if (FAILED(hr))
{
delete result;
return NULL;
}
result->vertexType = vertexType;
result->count = vertexCount;
result->access = access;
return result;
}
void BezierCurve::addPoint(int position, const QPointF point)
{
if ( position > -1 && position < getVertexSize() )
{
QPointF v1 = getVertex(position-1);
QPointF v2 = getVertex(position);
QPointF c1o = getC1(position);
QPointF c2o = getC2(position);
c1[position] = point + 0.2*(v2-v1);
c2[position] = v2 + (c2o-v2)*(0.5);
c1.insert(position, v1 + (c1o-v1)*(0.5) );
c2.insert(position, point - 0.2*(v2-v1));
vertex.insert(position, point);
pressure.insert(position, getPressure(position));
selected.insert(position, isSelected(position) && isSelected(position-1));
//smoothCurve();
}
else
{
qDebug() << "Error BezierCurve::addPoint(int, QPointF)";
}
}
VertexBuffer *DX9Render::createVertexBuffer(int vertexCount, int vertexType, void *data, bool access)
{
DX9VertexBuffer *result = new DX9VertexBuffer();
result->buffer = 0;
int byteSize = getVertexSize(vertexType) * vertexCount;
HRESULT hr = device->CreateVertexBuffer(byteSize, 0, 0, D3DPOOL_DEFAULT, &result->buffer, NULL);
if (FAILED(hr))
{
delete result;
return NULL;
}
// Fill newely created vertex buffer with data
void *lockedMemory = 0;
result->buffer->Lock(0, byteSize, &lockedMemory, 0);
memcpy(lockedMemory, data, byteSize);
result->buffer->Unlock();
result->vertexType = vertexType;
result->count = vertexCount;
result->access = access;
return result;
}
void BezierCurve::addPoint(int position, const qreal t) // t is the fraction where to split the bezier curve (ex: t=0.5)
{
// de Casteljau's method is used
// http://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm
// http://www.damtp.cam.ac.uk/user/na/PartIII/cagd2002/halve.ps
if ( position > -1 && position < getVertexSize() )
{
QPointF vA = getVertex(position-1);
QPointF vB = getVertex(position);
QPointF c1o = getC1(position);
QPointF c2o = getC2(position);
QPointF c12 = (1-t)*c1o + t*c2o;
QPointF cA1 = (1-t)*vA + t*c1o;
QPointF cB2 = (1-t)*c2o + t*vB;
QPointF cA2 = (1-t)*cA1 + t*c12;
QPointF cB1 = (1-t)*c12 + t*cB2;
QPointF vM = (1-t)*cA2 + t*cB1;
setC1(position, cB1);
setC2(position, cB2);
c1.insert(position, cA1);
c2.insert(position, cA2);
vertex.insert(position, vM);
pressure.insert(position, getPressure(position));
selected.insert(position, isSelected(position) && isSelected(position-1));
//smoothCurve();
}
else
{
qDebug() << "Error BezierCurve::addPoint(int, qreal)";
}
}
void VertexArray::setVertexAttribute(Int32 vertexIndex, Int32 attributeIndex, void* data)
{
char* dataAddress = reinterpret_cast<char*>(data);
char* addressOfTarget = &dataAddress[0] + (getVertexSize() * vertexIndex) + getAttributeOffset(attributeIndex);
memcpy(addressOfTarget, data, format.attributes[attributeIndex].size * format.attributes[attributeIndex].numComponents);
}
void VertexArray::allocateData(Int32 vertexCount)
{
Int32 bytesPerVertex = getVertexSize();
_data.resize(bytesPerVertex * vertexCount);
count = vertexCount;
}
void VertexDeclaration::calculateStrides()
{
uint8 vertexSize = getVertexSize();
for(size_t i = 0; i < decls.size(); ++i)
{
VertexElement& elem = decls[i];
elem.stride = vertexSize;
elem.offset = getOffset(elem.attribute);
}
}
void VertexArray::swapVertices(Int32 index, Int32 goesTo)
{
char* tbuffer = new char[getVertexSize()];
// get the temp buffer from the index vertex
memcpy(tbuffer, &_data[0] + getVertexSize() * index, getVertexSize());
// copy goesTo to the index vertex
memcpy(&_data[0] + getVertexSize() * index, &_data[0] + getVertexSize() * goesTo, getVertexSize());
// copy temp buffer to goesTo now
memcpy(&_data[0] + getVertexSize() * goesTo, tbuffer, getVertexSize());
delete[] tbuffer;
}
MeshResourceData* MeshLoader_dfmesh(ResourceDataSource &dataSource, Allocator &alloc)
{
DFMeshHeader header;
dataSource.getObjects(&header, 1);
if (strncmp((const char *)&header.magic, "DFME", 4) != 0)
{
DFLOG_WARN("Invalid dfmesh magic");
return nullptr;
}
if (header.version != DFMESH_VERSION)
{
DFLOG_WARN("Unsupported dfmesh version %d", header.version);
return nullptr;
}
// FIXME: quad.mesh HACK
if (header.vertexFormat == 0)
DF3D_ASSERT(header.indexSize == sizeof(uint16_t));
// TODO: vertex format is hardcoded.
auto vf = VertexFormat_dfmesh(header.vertexFormat);
auto result = MAKE_NEW(alloc, MeshResourceData)();
dataSource.seek(header.submeshesOffset, SeekDir::BEGIN);
for (int i = 0; i < header.submeshesCount; i++)
{
DFMeshSubmeshHeader smHeader;
dataSource.getObjects(&smHeader, 1);
const size_t verticesCount = smHeader.vertexDataSizeInBytes / vf.getVertexSize();
const size_t indicesCount = smHeader.indexDataSizeInBytes / header.indexSize;
auto meshPart = MAKE_NEW(alloc, MeshResourceData::Part)(vf, alloc);
meshPart->vertexData.addVertices(verticesCount);
dataSource.getObjects((uint8_t*)meshPart->vertexData.getRawData(), meshPart->vertexData.getSizeInBytes());
meshPart->indexData.resize(indicesCount);
dataSource.getObjects(meshPart->indexData.data(), indicesCount);
meshPart->materialName = smHeader.materialId;
result->parts.push_back(meshPart);
}
return result;
}
int Graph::rmVertex(Vertex const &v) {
int vpos = getPos(v);
if(vpos < getVertexSize()) {
vector<Vertex *>::iterator iv = _vertexList.begin() + vpos;
Vertex *tmp = *iv;
vector<Edge *> adjEdge = tmp->getAdj();
for(auto edge : adjEdge) {
rmEdge(*edge);
}
_vertexList.erase(iv);
delete tmp;
}
return vpos;
}
void VertexGenerator::Mesh2D::dumpInfo()
{
LOG_INFO("<-Dumpping Mesh2D information->\n");
LOG_INFO("Vertex Point Count: %d, Vertex Size: %d, TexCoords Size: %d, Byte Stride: %d\n",
getVertexCount(), getVertexSize(), getTexCoordsSize(), getByteStride());
for(size_t i = 0; i < getVertexCount(); ++i)
{
float* position = getPositions() + getStride() * i;
LOG_INFO("VertexPosition[%d]: %f, %f\n", i, *position, *(position + 1));
}
for(size_t i = 0; i < getVertexCount(); ++i)
{
float* texCoords = getTexCoords() + getStride() * i;
LOG_INFO("TexCoords[%d]: %f, %f\n", i, *texCoords, *(texCoords + 1));
}
}
Splat Reader::decode(const char *buffer, std::size_t offset) const
{
buffer += offset * getVertexSize();
Splat ans;
std::memcpy(&ans.position[0], buffer + offsets[X], sizeof(float));
std::memcpy(&ans.position[1], buffer + offsets[Y], sizeof(float));
std::memcpy(&ans.position[2], buffer + offsets[Z], sizeof(float));
std::memcpy(&ans.radius, buffer + offsets[RADIUS], sizeof(float));
std::memcpy(&ans.normal[0], buffer + offsets[NX], sizeof(float));
std::memcpy(&ans.normal[1], buffer + offsets[NY], sizeof(float));
std::memcpy(&ans.normal[2], buffer + offsets[NZ], sizeof(float));
ans.radius = std::min(ans.radius, maxRadius);
ans.radius *= smooth;
ans.quality = 1.0 / (ans.radius * ans.radius);
return ans;
}
/** Method to scale the positions in the mesh. Normals will be kept as is. This is a potentially slow operation, use with care.
* It will also create a temporary float[] which will be garbage collected.
*
* @param scaleX scale on x
* @param scaleY scale on y
* @param scaleZ scale on z */
void Mesh::scale (float scaleX, float scaleY, float scaleZ)
{
//TODO:
VertexAttribute posAttr(-1, 0, "");
getVertexAttribute(VertexAttributes::Position, posAttr);
int offset = posAttr.offset / 4;
int numComponents = posAttr.numComponents;
int numVertices = getNumVertices();
int vertexSize = getVertexSize() / 4;
float* vertices = new float[numVertices * vertexSize];
memcpy(vertices, m_vertices->getBuffer(), sizeof(float) * numVertices * vertexSize);
int idx = offset;
switch (numComponents)
{
case 1:
for (int i = 0; i < numVertices; i++)
{
vertices[idx] *= scaleX;
idx += vertexSize;
}
break;
case 2:
for (int i = 0; i < numVertices; i++)
{
vertices[idx] *= scaleX;
vertices[idx + 1] *= scaleY;
idx += vertexSize;
}
break;
case 3:
for (int i = 0; i < numVertices; i++)
{
vertices[idx] *= scaleX;
vertices[idx + 1] *= scaleY;
vertices[idx + 2] *= scaleZ;
idx += vertexSize;
}
break;
}
setVertices(vertices, numVertices * vertexSize);
delete [] vertices;
}
/// Get the pointer to the attribute data of a given vertex
char* VertexArray::getAttribute(Int32 attributeIndex, Int32 vertexIndex)
{
return &_data[0] + (getVertexSize() * vertexIndex) + getAttributeOffset(attributeIndex);
}
void VertexArray::removeLast()
{
_data.resize(_data.size() - getVertexSize());
count--;
}
/// Get the stride between vertices
std::size_t VertexArray::stride() const
{
return getVertexSize();
}
