コード例 #1
0
int BigNum::intoBinary(RawBuffer &buffer) const
{
    int len = (bitLength(*this)+7)/8;

	buffer.erase();

    int pos = 0;
    int bitpos = 0;

    // Index in reverse to get LSB first
    for (int i = len-1; i >= 0; --i)
    {
        int b = (((unsigned int)n[pos] >> bitpos) & 0xFFL);
        bitpos += 8;
        if (bitpos >= BITS)
        {
            bitpos -= BITS;
            pos++;
            if (bitpos > 0)
                b |= (n[pos] << (8-bitpos)) & 0xFFL;
        }
        buffer.insert((int)0,1,(unsigned char)b);
    }

	if(!negative && (char)buffer[0] < 0)
		buffer.insert((int)0,1,(unsigned char)0);

    return len;
}
コード例 #2
0
void BigNum::fromBinary(const RawBuffer &buffer)
{
    negative = false;    // Can't init negatives yet
    int alen = (buffer.length()*8 + BITS-1) / BITS;
    grow(*this, alen, false);
	len = alen;

    int pos = 0;
    n[pos] = 0;
    int bitpos = 0;
    // Index in reverse to get LSB first
    for (int i = buffer.length()-1; i >= 0; --i)
    {
        word b = buffer[i] & 0xFF;

        n[pos] |= (b << bitpos);
        bitpos += 8;
        if (bitpos >= BITS && i>0)
        {
            pos++;
            n[pos] = 0;
            bitpos -= BITS;
            if (bitpos > 0)
                n[pos] = b >> (8-bitpos);
        }
    }
コード例 #3
0
ファイル: mem_alloc.cpp プロジェクト: qcs4tracy/HttpProxy
size_t BufferChain::write(const char *data, size_t size) {
    
    RawBuffer *buf = _lastAvail;
    size_t nLeft = size;
    size_t nw = 0;
    
    //the buffer chain is empty
    if ((!buf && _chain.empty()) || buf->isFull()) {
        buf = addNewBuffer();
    }
    
    do {
        nw = buf->write(data, nLeft);
        nLeft -= nw;
        data += nw;
        //if the current buffer is full
        if (buf->isFull()) {
            buf = addNewBuffer();
        }
    } while (nLeft > 0);
    
    _totalBytes += (size - nLeft);
    
    return size - nLeft;
}
コード例 #4
0
ファイル: AuthContext.cpp プロジェクト: Joincheng/lithtech
void AuthContext::AppendHashes(WriteBuffer &theBuf, const RawBuffer &theChallengeSeed)
{
	AutoCrit aCrit(mDataCrit);

	int aNumHashes = 0;
	int aNumHashPos = theBuf.length();
	theBuf.SkipBytes(1); // put num hashes here

	AuthLoginCommunityMap::iterator anItr = mCommunityMap.begin();
	while(anItr!=mCommunityMap.end())
	{
		AuthLoginCommunityData &aData = anItr->second;
		if(!aData.mSimpleHash.empty())
		{
			MD5Digest aKeyedHash;
			aKeyedHash.update(theChallengeSeed);
			aKeyedHash.update(aData.mKeyedHashData);
			RawBuffer aKeyedHashBuf = aKeyedHash.digest();		
	

			theBuf.AppendByte(1); // hash tag
			theBuf.AppendWString(anItr->first); // community
			theBuf.AppendBytes(aData.mSimpleHash.data(),aData.mSimpleHash.length());
			theBuf.AppendBytes(aKeyedHashBuf.data(),aKeyedHashBuf.length());
			aNumHashes++;
		}

		++anItr;
	}

	theBuf.SetByte(aNumHashPos,aNumHashes);
}
コード例 #5
0
ファイル: dmabuffereduart.cpp プロジェクト: 980f/cortexm
void DmaBufferedUart::packDmaArgs(DmaChannel::StreamDefinition&def, RawBuffer&rb, int subset ){
  def.device = &Uart::dcb->DR;
  def.devicesize = 2; //uart allows for 9 bit words, like 8051 multidrop protocol or forced parity
  def.buffer = rb.item(0);
  def.numItems = subset > 0 ? subset : rb.length();
  def.itemsize = rb.itemSize();
}
コード例 #6
0
// ClientCDKey::CreateSymmetricKey
// Creates a symmetric key from product name used to save/load CD-Key to/from
// the registry.  Symmetric key is created via a series of CRCs on the product.
void
ClientCDKey::CreateSymmetricKey(BFSymmetricKey& theSymKeyR) const
{
	WTRACE("ClientCDKey::CreateSymmetricKey");
	WDBG_LL("ClientCDKey::CreateSymmetricKey from product=" << mProduct);
	CRC16     aCRC;
	RawBuffer aBuf;

	// CRC the product and use it as 1st 2 bytes of key
	aCRC.Put(mProduct);
	unsigned short aCheckSum = aCRC.GetCRC();
	WDBG_LL("ClientCDKey::CreateSymmetricKey First CRC=" << aCheckSum);
	aBuf.assign(reinterpret_cast<unsigned char*>(&aCheckSum), sizeof(aCheckSum));

	// CRC each of 1st 3 chars of product and add them to key.
	for (int i=0; (i < 3) && (i < mProduct.size()); i++)
	{
		aCRC.Put(static_cast<unsigned char>(mProduct[i]));
		aCheckSum = aCRC.GetCRC();
		WDBG_LL("ClientCDKey::CreateSymmetricKey Add CRC=" << aCheckSum);
		aBuf.append(reinterpret_cast<unsigned char*>(&aCheckSum), sizeof(aCheckSum));
	}

	// Create the key
	WDBG_LL("ClientCDKey::CreateSymmetricKey Buf=" << aBuf);
	theSymKeyR.Create(aBuf.size(), aBuf.data());
}
コード例 #7
0
ファイル: SocketChannel.cpp プロジェクト: yzoprj/trunk
int SocketChannel::writeN(const RawBuffer &rb, const CommunicatioInformation &ci)
{
	MutexGuard mg(SessionManager::sockSendMuetx);
	
	SOCKADDR_IN addr = {0};
	int addrSize = sizeof(addr);
	addr.sin_family = AF_INET;
	addr.sin_port = ci.port;
	addr.sin_addr.S_un.S_addr = ci.hostAddress;

	return sendto(_sock.getHandle(), (char *)rb.getData(), rb.getLength(), 0, (sockaddr *)&addr, addrSize);
}
コード例 #8
0
ファイル: ChatView.cpp プロジェクト: vgck/opendr2
void CChatView::CreateBoard(const CString& theRoomName)
{
	// Our Document
	CWhiteBoardDoc* pDoc = (CWhiteBoardDoc*)GetDocument();

	// Construct the objects for CreateDataObjectEx
	RawBuffer aObjectName(OBJ_GAMEPREFIX + (unsigned char*)(LPCSTR)theRoomName);
	RawBuffer aObject;

	pDoc->mObserverIds[0] = pDoc->mRoutingServer.GetClientId();
	pDoc->mNumObservers = 1;						/* only 1 since we just created it */
	aObject.assign((unsigned char*)pDoc->mObserverIds);

	pDoc->mRoutingServer.CreateDataObjectEx(RoutingServerClient::GROUPID_ALLUSERS, aObjectName, pDoc->mRoutingServer.GetClientId(), 0, aObject, (void(*)(short, CChatView*))CreateDataObjectCallback, this);
}
コード例 #9
0
ファイル: BigInteger.cpp プロジェクト: vgck/opendr2
unsigned __int64 BigInteger::GetInt64() const
{
	BigInteger r;
	unsigned __int64 aVal = 0;

	RawBuffer aBuf = toByteArray();
	for(int i=0; i<aBuf.length(); i++)
	{
		aVal = (aVal<<8)|aBuf[i];
	}

	return aVal;


}
コード例 #10
0
ファイル: ChatView.cpp プロジェクト: vgck/opendr2
/********************************************************************************
 * Subscribe to the game list in the current chat room							*
 ********************************************************************************/
void CChatView::SubscribeDataObjectCallback(const WONAPI::RoutingServerClient::ReadDataObjectResult& theResultR, CChatView* pThat)
{
	// Check the result from SubscribeDataObject	
	switch (theResultR.mStatus)
	{
		case StatusCommon_Success:
			{
			// List retrieved
			pThat->DisplayText("<System> Subscribed to game list successfully\r\n");

			for (std::list<RoutingServerClient::DataObject>::const_iterator itr = theResultR.mDataObjectList.begin(); itr != theResultR.mDataObjectList.end(); itr++)
			{
				// Store the games in our GameMap
				string gamename = (char*)itr->mDataType.data() + OBJ_GAMEPREFIX.size();
				((CWhiteBoardDoc*)pThat->GetDocument())->mGameMap[gamename] = *itr; 
			}
			break;
			}
		case StatusRouting_SubscriptionAlreadyExists:
			pThat->DisplayText("<System> ***ERROR Attemp to subscribe twice***\r\n");
			break;
		default:
			pThat->DisplayText("<System> ***ERROR Failed to retrieve game list***\r\n");
			break;
	}
};
コード例 #11
0
ファイル: SocketChannel.cpp プロジェクト: yzoprj/trunk
int SocketChannel::readN(RawBuffer &rb)
{
	int hasRecvCounts = 0;
	char buffer[MAX_BUFFER_LENGTH] = {0};
	int result = 0;

	while ((result = recv((SOCKET)_sock.getHandle(), buffer + hasRecvCounts, MAX_BUFFER_LENGTH - hasRecvCounts, 0)))
	{
		if (result < 0)
		{
			if (errno == EWOULDBLOCK)
			{
				break;
			}else if ( errno == EINTR)
			{
				break;
			}
		}else if (result == 0)
		{
			break;
		}

		hasRecvCounts += result;
		
	}
	result = handleResultErrorResult(result);

	if (result > 0)
	{
		rb.setRawData((unsigned char *)buffer, (unsigned int)hasRecvCounts);
		result = hasRecvCounts;
	}

	return result;
}
コード例 #12
0
ファイル: WhiteBoardView.cpp プロジェクト: vgck/opendr2
/********************************************************************************
 * Whenever the mouse moves. We need to track the path of each stroke			*
 ********************************************************************************/
void CWhiteBoardView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// Our Document
	CWhiteBoardDoc* pDoc = GetDocument();

	// If we're not drawing we don't need to process a mouse release
	if (bIsDrawing==false)
	{
		CScrollView::OnLButtonUp(nFlags, point);
		return;
	}

	// Finish the stroke
	

	// If we're connected to a board room let's relay this stroke to any observers
	if (pDoc->bOnBoard)
	{
		// Allocate a linear buffer for data storage (5 = size of message header)
		int buf_size = pDoc->m_pCurStroke->GetSize();
		unsigned char* pDataBuffer = new unsigned char[buf_size];

		// Store the stroke data into the buffer
		pDoc->m_pCurStroke->StoreToBuffer(pDataBuffer);

		// Copy the character buffer into a server readable rawbuffer for net transfer
		RawBuffer theRawBuf;
		theRawBuf.assign(pDataBuffer, buf_size);
		
		// Relay the stroke to all observers
		pDoc->mRoutingServer.SendData(pDoc->mObserverIds, pDoc->mNumObservers, true, theRawBuf, false);

		// delete our linear buffer
		delete[] pDataBuffer;
	}

	// Release the mouse, we don't need it anymore
	ReleaseCapture();

	// No Longer Drawing
	bIsDrawing = false;
	pDoc->m_pCurStroke = NULL;

	// Call the base class implementation
	CScrollView::OnLButtonUp(nFlags, point);
}
コード例 #13
0
EGPublicKey::CryptReturn EGPublicKey::Encrypt(const void* theMsgP, unsigned long theLen) const
{
	if ((! theMsgP) || (theLen == 0))
	{
		return CryptReturn(NULL,0);
	}


	RawBuffer anEncrypt;
	if(!mElGamal.encrypt(theMsgP,theLen,anEncrypt))
		return CryptReturn(NULL,0);

	unsigned char *anOutP = new unsigned char[anEncrypt.length()];
	memcpy(anOutP,anEncrypt.data(),anEncrypt.length());

	return CryptReturn(anOutP,anEncrypt.length());
}
コード例 #14
0
bool ElGamal::EncodeDigest(const RawBuffer& digest, BigInteger &h) const
{
    IntegerExtractor aDecoder(digest.data(),digest.length(),false);
    if(digest.length()*8 < q.bitLength())
    {
        if(!aDecoder.Decode(digest.length(),h))
            return false;
    }
    else
    {
        if(!aDecoder.Decode(q.byteLength(),h))
            return false;

        h = h.shiftRight(q.byteLength()*8 - q.bitLength() + 1);
    }

    return true;
}
コード例 #15
0
ファイル: key-aes-impl.cpp プロジェクト: Samsung/ckm
KeyAESImpl::KeyAESImpl(const RawBuffer &buf) : m_key(buf)
{
    // buf stores bytes -> compare the bit sizes
    switch (buf.size() * 8) {
    case 128:
    case 192:
    case 256:
        break;

    default:
        throw std::invalid_argument("invalid AES key size");
    }
}
コード例 #16
0
ファイル: AuthContext.cpp プロジェクト: Joincheng/lithtech
bool AuthContext::LoadVerifierKey(const std::string &theFile)
{
	mCheckedVerifierFile = true;

	FILE *aFile = fopen(theFile.c_str(),"rb");
	if(aFile==NULL)
		return false;

	unsigned char aBuf[1024];
	RawBuffer aKeyBuf;
	while(!feof(aFile))
	{
		int aNumRead = fread(aBuf,1,1024,aFile);
		if(aNumRead>0)
			aKeyBuf.append(aBuf,aNumRead);
	
	}

	fclose(aFile);
	
	AutoCrit aCrit(GetVerifierCrit());
	return mVerifierKey.SetPublicKey(aKeyBuf.data(),aKeyBuf.length());
}
コード例 #17
0
ファイル: SocketChannel.cpp プロジェクト: yzoprj/trunk
int SocketChannel::readN(RawBuffer &rb, CommunicatioInformation &ci)
{
	char buffer[MAX_READ_BUFFER_SIZE] = {0};

	SOCKADDR_IN addr = {0};
	int addrSize = sizeof(addr);
	int result = -1;

	result = recvfrom(_sock.getHandle(), buffer, MAX_READ_BUFFER_SIZE, 0, (sockaddr *)&addr, &addrSize);



	if (result > 0)
	{
		rb.setRawData((unsigned char *)buffer, result);
		ci.hostAddress = addr.sin_addr.S_un.S_addr;
		ci.port = addr.sin_port;
		ci.setConnectionType(CT_Socket);
		ci.setSocketMode(SM_UDP);
	}

	return result;

}
コード例 #18
0
ファイル: SocketChannel.cpp プロジェクト: yzoprj/trunk
int SocketChannel::writeN(const RawBuffer &rb)
{
	int result = send((SOCKET)_sock.getHandle(), (char *)rb.getData(), rb.getLength(), 0);
	return handleResultErrorResult(result);
}
コード例 #19
0
ファイル: matchmaker.cpp プロジェクト: vgck/opendr2
void Matchmaker::GetTitanServerList()
{
#ifdef DLLSAMPLE
	mNewAuthServers.clear();
	mNewContestServers.clear();
	mNewEventServers.clear();
	mNewFirewallServers.clear();
	mNewProfileServers.clear();
	
	HWONDATAOBJECT aDataObjectH = WONDataObjectCreate(OBJ_VALIDVERSIONS.c_str(), OBJ_VALIDVERSIONS.size(), NULL, 0);
	WONError aError = WONDirGetDirectoryW(NULL, mDirServers, mNumDirServers,
	                                      DIR_TITANSERVER, NULL, NULL,
	                                      WONDir_GF_DECOMPROOT | WONDir_GF_DECOMPRECURSIVE | WONDir_GF_DECOMPSERVICES | WONDir_GF_ADDTYPE | WONDir_GF_SERVADDNAME | WONDir_GF_SERVADDNETADDR | WONDir_GF_ADDDOTYPE | WONDir_GF_ADDDODATA,
	                                      &aDataObjectH, 1, TitanServerEntityCallback, this, gRequestTimeout);

	CopySTLAddressListToArray(mNewAuthServers,     &mAuthServers,     &mNumAuthServers);
	CopySTLAddressListToArray(mNewContestServers,  &mContestServers,  &mNumContestServers);
	CopySTLAddressListToArray(mNewEventServers,    &mEventServers,    &mNumEventServers);
	CopySTLAddressListToArray(mNewFirewallServers, &mFirewallServers, &mNumFirewallServers);
	CopySTLAddressListToArray(mNewProfileServers,  &mProfileServers,  &mNumProfileServers);
#else
	DataObjectTypeSet aDataObjectSet;
	aDataObjectSet.insert(WONCommon::DataObject(OBJ_VALIDVERSIONS));
	WONMsg::DirEntityList entityList;
	Error aError = GetDirectory(NULL, // no identity needed to get TitanServers (after all, the AuthServers are listed in there)
								mDirServers, mNumDirServers,
								NULL,
								DIR_TITANSERVER, 
								&entityList,
								WONMsg::GF_DECOMPROOT | WONMsg::GF_DECOMPRECURSIVE | WONMsg::GF_DECOMPSERVICES | WONMsg::GF_ADDTYPE | WONMsg::GF_SERVADDNAME | WONMsg::GF_SERVADDNETADDR | WONMsg::GF_ADDDOTYPE | WONMsg::GF_ADDDODATA,
								aDataObjectSet,
								0, 0,
								gRequestTimeout);

	switch(aError) 
	{
		case Error_Success:
		{
			delete[] mAuthServers; mNumAuthServers = 0;
			mAuthServers = new IPSocket::Address[entityList.size()];
			delete[] mContestServers; mNumContestServers = 0;
			mContestServers = new IPSocket::Address[entityList.size()];
			delete[] mEventServers; mNumEventServers = 0;
			mEventServers = new IPSocket::Address[entityList.size()];
			delete[] mFirewallServers; mNumFirewallServers = 0;
			mFirewallServers = new IPSocket::Address[entityList.size()];
			delete[] mProfileServers; mNumProfileServers = 0;
			mProfileServers = new IPSocket::Address[entityList.size()];

			DirEntityList::const_iterator aDirEntityListItr = entityList.begin();
			for( ; aDirEntityListItr != entityList.end(); ++aDirEntityListItr)
			{
				if (aDirEntityListItr->mType == WONMsg::DirEntity::ET_DIRECTORY)
				{
					DataObjectTypeSet::const_iterator aDataObjectSetItr = aDirEntityListItr->mDataObjects.begin();
					for( ; aDataObjectSetItr != aDirEntityListItr->mDataObjects.end(); ++aDataObjectSetItr)
					{
						if (aDataObjectSetItr->GetDataType() == OBJ_VALIDVERSIONS)
							mValidVersions = reinterpret_cast<const char*>(aDataObjectSetItr->GetData().c_str());
					}
				}
				else if (aDirEntityListItr->mName == SERVERNAME_AUTH)
					mAuthServers[mNumAuthServers++] = IPSocket::Address(*aDirEntityListItr);
				else if (aDirEntityListItr->mName == SERVERNAME_CONTEST)
					mContestServers[mNumContestServers++] = IPSocket::Address(*aDirEntityListItr);
				else if (aDirEntityListItr->mName == SERVERNAME_EVENT)
					mEventServers[mNumEventServers++] = IPSocket::Address(*aDirEntityListItr);
				else if (aDirEntityListItr->mName == SERVERNAME_FIREWALL)
					mFirewallServers[mNumFirewallServers++] = IPSocket::Address(*aDirEntityListItr);
				else if (aDirEntityListItr->mName == SERVERNAME_PROFILE)
					mProfileServers[mNumProfileServers++] = IPSocket::Address(*aDirEntityListItr);
			}
			break;
		}

		case StatusDir_DirNotFound:
			OutputError("Directory containing Titan servers not found");
			break;
		default:
			OutputError("Failed to get list of Titan servers!", aError);
			break;
	}
#endif // DLLSAMPLE
}
コード例 #20
0
ファイル: Mesh.cpp プロジェクト: evehj/NDKOpenGLES2App
  /** original mesh file format.

	char[3]           "MSH"
	uint8_t           mesh count.
	reserved          (2 byte)
	uint32_t          vbo offset by the top of file(32bit alignment).
	uint32_t          vbo byte size(32bit alignment).
	uint32_t          ibo byte size(32bit alignment).

	[
	  uint8_t         mesh name length.
	  char[mesh name length] mesh name(without zero ternmination).
	  uint8_t         material count.
	  padding         (4 - (length + 2) % 4) % 4 byte.
	  [
		uint32_t        ibo offset.
		uint16_t        ibo size(this is the polygon counts, so actual ibo size is 3 times).
		uint8_t         red
		uint8_t         green
		uint8_t         blue
		uint8_t         alpha
		uint8_t         metallic
		uint8_t         roughness
		] x (ibo count)
	] x (mesh count)

	uint8_t                          albedo texture name length.
	char[albedo texture name length] albedo texture name(without zero ternmination).
	uint8_t                          normal texture name length.
	char[normal texture name length] normal texture name(without zero ternmination).
	padding                          (4 - (texture name block size % 4) % 4 byte.

	vbo               vbo data.
	ibo               ibo data.
	padding           (4 - (ibo byte size % 4) % 4 byte.

	uint16_t          bone count.
	uint16_t          animation count.

	[
	  RotTrans        rotation and translation for the bind pose.
	  int32_t         parent bone index.
	] x (bone count)

	[
	  uint8_t         animation name length.
	  char[24]        animation name.
	  bool            loop flag
	  uint16_t        key frame count.
	  float           total time.
	  [
		float         time.
		[
		  RotTrans    rotation and translation.
		] x (bone count)
	  ] x (key frame count)
	] x (animation count)
  */
  ImportMeshResult ImportMesh(const RawBuffer& data, GLuint& vbo, GLintptr& vboEnd, GLuint& ibo, GLintptr& iboEnd)
  {
	const uint8_t* p = &data[0];
	const uint8_t* pEnd = p + data.size();
	if (p[0] != 'M' || p[1] != 'S' || p[2] != 'H') {
	  return ImportMeshResult(ImportMeshResult::Result::invalidHeader);
	}
	p += 3;
	const int count = *p;
	p += 1;
	/*const uint32_t vboOffset = GetValue(p, 4);*/ p += 4;
	const uint32_t vboByteSize = GetValue(p, 4); p += 4;
	const uint32_t iboByteSize = GetValue(p, 4); p += 4;
	if (p >= pEnd) {
	  return ImportMeshResult(ImportMeshResult::Result::noData);
	}

	GLuint iboBaseOffset = iboEnd;
	ImportMeshResult  result(ImportMeshResult::Result::success);
	result.meshes.reserve(count);
	for (int i = 0; i < count; ++i) {
	  Mesh m;
	  const uint32_t nameLength = *p++;
	  m.id.assign(p, p + nameLength); p += nameLength;
	  const size_t materialCount = *p++;
	  p += (4 - (nameLength + 2) % 4) % 4;
	  m.materialList.resize(materialCount);
	  for (auto& e : m.materialList) {
		e.iboOffset = iboBaseOffset; p += 4;
		e.iboSize = GetValue(p, 2); p += 2;
		e.material.color.r = *p++;
		e.material.color.g = *p++;
		e.material.color.b = *p++;
		e.material.color.a = *p++;
		e.material.metallic.Set(static_cast<float>(*p++) / 255.0f);
		e.material.roughness.Set(static_cast<float>(*p++) / 255.0f);
		iboBaseOffset += e.iboSize * sizeof(GLushort);
	  }
	  result.meshes.push_back(m);
	  if (p >= pEnd) {
		return ImportMeshResult(ImportMeshResult::Result::invalidMeshInfo);
	  }
	}

	glBufferSubData(GL_ARRAY_BUFFER, vboEnd, vboByteSize, p);
	p += vboByteSize;
	if (p >= pEnd) {
	  return ImportMeshResult(ImportMeshResult::Result::invalidVBO);
	}

	std::vector<GLushort>  indices;
	indices.reserve(iboByteSize / sizeof(GLushort));
	const uint32_t offsetTmp = vboEnd / sizeof(Vertex);
	if (offsetTmp > 0xffff) {
	  return ImportMeshResult(ImportMeshResult::Result::indexOverflow);
	}
	const GLushort offset = static_cast<GLushort>(offsetTmp);
	for (uint32_t i = 0; i < iboByteSize; i += sizeof(GLushort)) {
	  indices.push_back(*reinterpret_cast<const GLushort*>(p) + offset);
	  p += sizeof(GLushort);
	  if (p >= pEnd) {
		return ImportMeshResult(ImportMeshResult::Result::invalidIBO);
	  }
	}
	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, iboEnd, iboByteSize, &indices[0]);

	vboEnd += vboByteSize;
	iboEnd += iboByteSize;

	p += (4 - (reinterpret_cast<intptr_t>(p) % 4)) % 4;
	if (p >= pEnd) {
	  return result;
	}

	const uint32_t boneCount = GetValue(p, 2); p += 2;
	const uint32_t animationCount = GetValue(p, 2); p += 2;

	if (boneCount) {
	  JointList joints;
	  joints.resize(boneCount);
	  std::vector<std::vector<int>> parentIndexList;
	  parentIndexList.resize(boneCount);
	  for (uint32_t i = 0; i < boneCount; ++i) {
		if (p >= pEnd) {
		  return ImportMeshResult(ImportMeshResult::Result::invalidJointInfo);
		}
		Joint& e = joints[i];
		e.invBindPose.rot.x = GetFloat(p);
		e.invBindPose.rot.y = GetFloat(p);
		e.invBindPose.rot.z = GetFloat(p);
		e.invBindPose.rot.w = GetFloat(p);
		e.invBindPose.rot.Normalize();
		e.invBindPose.trans.x = GetFloat(p);
		e.invBindPose.trans.y = GetFloat(p);
		e.invBindPose.trans.z = GetFloat(p);
#if 0
		const Matrix4x3 m43 = ToMatrix(e.invBindPose.rot);
		Matrix4x4 m44;
		m44.SetVector(0, m43.GetVector(0));
		m44.SetVector(1, m43.GetVector(1));
		m44.SetVector(2, m43.GetVector(2));
		m44.SetVector(3, e.invBindPose.trans);
		m44.Inverse();
		Vector3F scale;
		m44.Decompose(&e.initialPose.rot, &scale, &e.initialPose.trans);
#else
		e.initialPose.rot = e.invBindPose.rot.Inverse();
		e.initialPose.trans = e.initialPose.rot.Apply(-e.invBindPose.trans);
#endif
		e.offChild = 0;
		e.offSibling = 0;
		const uint32_t parentIndex = GetValue(p, 4); p += 4;
		if (parentIndex != 0xffffffff) {
		  parentIndexList[parentIndex].push_back(i);
		}
	  }
	  for (uint32_t i = 0; i < boneCount; ++i) {
		const auto& e = parentIndexList[i];
		if (!e.empty()) {
		  int current = e[0];
		  joints[i].offChild = current - i;
		  Joint* pJoint = &joints[current];
		  for (auto itr = e.begin() + 1; itr != e.end(); ++itr) {
			const int sibling = *itr;
			pJoint->offSibling = sibling - current;
			pJoint = &joints[sibling];
			current = sibling;
		  }
		}
	  }
	  for (auto& e : result.meshes) {
		e.jointList = joints;
	  }
	}

	if (animationCount) {
	  LOGI("ImportMesh - Read animation:");
	  result.animations.reserve(animationCount);
	  for (uint32_t i = 0; i < animationCount; ++i) {
		Animation anm;
		const uint32_t nameLength = GetValue(p++, 1);
		char name[24];
		for (int i = 0; i < 24; ++i) {
		  name[i] = static_cast<char>(GetValue(p++, 1));
		}
		anm.id.assign(name, name + nameLength);
		anm.data.resize(boneCount);
		for (uint32_t bone = 0; bone < boneCount; ++bone) {
		  anm.data[bone].first = bone;
		}
		anm.loopFlag = static_cast<bool>(GetValue(p++, 1) != 0);
		const uint32_t keyframeCount = GetValue(p, 2); p += 2;
		anm.totalTime = GetFloat(p);
		LOGI("%s: %fsec", anm.id.c_str(), anm.totalTime);
		for (uint32_t keyframe = 0; keyframe < keyframeCount; ++keyframe) {
		  const float time = GetFloat(p);
#ifdef DEBUG_LOG_VERBOSE
		  LOGI("time=%f", time);
#endif // DEBUG_LOG_VERBOSE
		  for (uint32_t bone = 0; bone < boneCount; ++bone) {
			if (p >= pEnd) {
			  return ImportMeshResult(ImportMeshResult::Result::invalidAnimationInfo);
			}
			Animation::Element elem;
			elem.time = time;
			elem.pose.rot.x = GetFloat(p);
			elem.pose.rot.y = GetFloat(p);
			elem.pose.rot.z = GetFloat(p);
			elem.pose.rot.w = GetFloat(p);
			elem.pose.rot.Normalize();
			elem.pose.trans.x = GetFloat(p);
			elem.pose.trans.y = GetFloat(p);
			elem.pose.trans.z = GetFloat(p);
			anm.data[bone].second.push_back(elem);
#ifdef DEBUG_LOG_VERBOSE
			LOGI("%02d:(%+1.3f, %+1.3f, %+1.3f, %+1.3f) (%+1.3f, %+1.3f, %+1.3f)", bone, elem.pose.rot.w, elem.pose.rot.x, elem.pose.rot.y, elem.pose.rot.z, elem.pose.trans.x, elem.pose.trans.y, elem.pose.trans.z);
#endif // DEBUG_LOG_VERBOSE
		  }
		}
		result.animations.push_back(anm);
	  }
	}

	return result;
  }
コード例 #21
0
ファイル: HexBuffer.cpp プロジェクト: yzoprj/ORNG
HexBuffer::HexBuffer(const RawBuffer & rb)
{
	convert(rb.getData(), rb.getLength());
}
コード例 #22
0
ByteBufferPtr ElGamal::Decrypt(const void *theCipherText, int theCipherTextLen) const
{
    if(!IsPrivate())
        return NULL;

    const unsigned char *in = (const unsigned char*)theCipherText;
    int inOffset = 0;

    if(theCipherTextLen-inOffset<4) return NULL;
    int aNumBlocks = LongFromLittleEndian(*(int*)in);
    inOffset+=4;

    if(theCipherTextLen-inOffset < aNumBlocks*modulusLen*2-inOffset)
        return NULL;

    RawBuffer aBuf(modulusLen,(unsigned char)0);
    RawBuffer bBuf(modulusLen,(unsigned char)0);

    WriteBuffer aDecrypt;

    BigInteger a;;
    BigInteger b;

    BigInteger aPlainText;

    for(int i=0; i<aNumBlocks; i++)
    {
        aBuf.assign(in+inOffset,modulusLen);
        inOffset+=modulusLen;
        bBuf.assign(in+inOffset,modulusLen);
        inOffset+=modulusLen;

        a.fromBinary(aBuf);
        b.fromBinary(bBuf);

        if(!decrypt(a,b,aPlainText))
            return NULL;

        RawBuffer aBigIntArray;
        aPlainText.toBinary(aBigIntArray);


        if(aBigIntArray.length()==0) return NULL;
        int aPlainLen = aBigIntArray[aBigIntArray.length() - 1];

        if(aPlainLen>modulusLen - 3)
            return NULL;

        if(aBigIntArray.length() - 1 - aPlainLen < 0)
        {
            int extra = aPlainLen - (aBigIntArray.length() - 1);
            for(int j=0; j<extra; j++)
                aDecrypt.AppendByte(0);

            aDecrypt.AppendBytes(aBigIntArray.data(),aBigIntArray.length());
        }
        else
            aDecrypt.AppendBytes(aBigIntArray.data()+aBigIntArray.length()-1-aPlainLen,aPlainLen);
    }

    return aDecrypt.ToByteBuffer();
}