CVertices<Vertex, Allocator>&
CVertices<Vertex, Allocator>::SetByQuads(void)
{
const float halfWidth = 0.5f;
const float halfHeight = 0.5f;
Vertices().resize(4);
Vertices()[0].Position() = CVector3({ -halfWidth, -halfHeight, 0 });
Vertices()[0].UV()[0] = 0;
Vertices()[0].UV()[1] = 1;
Vertices()[1].Position() = CVector3({ -halfWidth, halfHeight, 0 });
Vertices()[1].UV()[0] = 0;
Vertices()[1].UV()[1] = 0;
Vertices()[2].Position() = CVector3({ halfWidth, -halfHeight, 0 });
Vertices()[2].UV()[0] = 1;
Vertices()[2].UV()[1] = 1;
Vertices()[3].Position() = CVector3({ halfWidth, halfHeight, 0 });
Vertices()[3].UV()[0] = 1;
Vertices()[3].UV()[1] = 0;
SetVertexData(Vertices());
SetPrimitiveType(
TRIANGLE_STRIP);
return *this;
};
VertexBufferGL::VertexBufferGL(VertV3FUV0UV1* vertices, unsigned int vertexTotal)
: VertexBuffer(vertices, vertexTotal)
{
// create GL buffers
m_bufferID = 0;
glGenBuffersARB(1, &m_bufferID);
m_indicesGL = NULL;
SetPrimitiveType(TRIANGLE_LIST);
}
UINT16 CQ931Pdu::WhatPrimitive(UINT16 mType, UINT8 ir)
{
UINT16 pType;
switch (mType)
{
case PSG_MSG_Q931_SETUP:
pType = (ir) ? PSG_CC_SETUP_REQ : PSG_CC_SETUP_IND;
break;
case PSG_MSG_Q931_ALERTING:
pType = (ir) ? PSG_CC_AC_REQ : PSG_CC_AC_IND;
break;
case PSG_MSG_Q931_CONNECT:
pType = (ir) ? PSG_CC_ANSWER_REQ : PSG_CC_ANSWER_IND;
break;
case PSG_MSG_Q931_DISCONNECT:
case PSG_MSG_Q931_RELEASE:
pType = (ir) ? PSG_CC_RELEASE_REQ : PSG_CC_RELEASE_IND;
break;
case PSG_MSG_Q931_RELEASE_COM:
pType = PSG_CC_RELEASE_IND;
break;
case PSG_MSG_Q931_RESTART:
// case PSG_MSG_Q931_FAIL:
pType = (ir) ? PSG_CC_CIRCUIT_REQ : PSG_CC_CIRCUIT_IND;
break;
default:
pType = (ir) ? PSG_CC_EVENT_REQ : PSG_CC_EVENT_IND;
} // End of switch(mType)
SetPrimitiveType(pType);
return pType;
}
void OGL4GeometryData::BeginGeometry(PRIMITIVE_TYPE prim)
{
SetPrimitiveType(prim);
glBindVertexArray(m_vao);
}
int CRANAPptl::parse(unsigned char* pdata, int len)
{
if(NULL == pdata || len < 4) return -1;
int iRet = 0;
asnContext context;
////////////////////////
//activate Trace Management and create a traceStream (optional)
//context.setEncodingTraceWhileEncoding(asnTRUE);
//context.setValueTraceWhileDecoding(asnTRUE);
//asnFileStream traceStream("traces.txt", // file name
// asnFSTREAM_TXT_WRITE );// write text stream
//context.setTraceStream(&traceStream);
////////////////////////
SetProtocolType(MOD_RANAP);
try
{
asnMemoryStream instream(pdata, len,asnFSTREAM_WRITE);
// decode the decoding stream into myDecodedValue
RANAP_PDU pdu;
asnMAXUINT iDecoded = pdu.PERdecode(&context, &instream);
// here pdu contains the decoded value
SetPrimitiveType(pdu.value->alternative);
switch(pdu.value->alternative)
{
case RANAP_TRIGGERMSG_INITIAL:// 0 InitiatingMessage
{
asncinitiatingMessage *initMsg = (asncinitiatingMessage *)(pdu.value);
SetMessageType(initMsg->procedureCode);
switch(initMsg->procedureCode)
{
case RANAP_DirectTransfer:// 20 DirectInformationTransfer
parseDirectTransfer(&context, (asnOpenType*)(initMsg->value));
break;
case RANAP_Paging:// 14 id-Paging
parsePaging(&context, (asnOpenType*)(initMsg->value));
break;
case RANAP_CommonID:// 15 id-CommonID
parseCommonID(&context, (asnOpenType*)(initMsg->value));
break;
case RANAP_InitialUE_Message:// 19 id-InitialUE-Message
parseInitialUEMessage(&context, (asnOpenType*)(initMsg->value));
break;
case RANAP_RAB_ASSIGNMENT:// 0 id-RAB-Assignment
parseRABAssignment(&context, (asnOpenType*)(initMsg->value));
break;
case RANAP_Iu_RELEASE:// 1 id-Iu-Release
parseIuRelease(&context, (asnOpenType*)(initMsg->value));
break;
default:
break;
}
}
break;
case RANAP_TRIGGERMSG_SUCCESS:// 1 SuccessfulOutcome
{
asncsuccessfulOutcome *pSuccess = (asncsuccessfulOutcome *)pdu.value;
SetMessageType(pSuccess->procedureCode);
switch(pSuccess->procedureCode)
{
case RANAP_Iu_RELEASE:// 1 id-Iu-Release
parseIuReleaseComplete(&context, (asnOpenType*)(pSuccess->value));
break;
default:
break;
}
}
break;
case RANAP_TRIGGERMSG_UNSUCCESS:// 2 UnsuccessfulOutcome
{
asncunsuccessfulOutcome *pUnSuccess = (asncunsuccessfulOutcome*)(pdu.value);
SetMessageType(pUnSuccess->procedureCode);
}
break;
case RANAP_TRIGGERMSG_OUTCOME:// 3 Outcome
{
asncRANAP_PDU__outcome *pOutcome = (asncRANAP_PDU__outcome *)pdu.value;
SetMessageType(pOutcome->procedureCode);
switch(pOutcome->procedureCode)
{
case RANAP_RAB_ASSIGNMENT:// 0 id-RAB-Assignment
parseRABAssignmentOutCome(&context, (asnOpenType*)(pOutcome->value));
break;
default:
break;
}
}
break;
default:
printf("choice: %hd\n", pdu.value->alternative);
break;
}
}
catch(asnException& e)
{
iRet = -1;
SetProtocolType(SV_CHINA_SCCP);
SetPrimitiveType(0);
SetMessageType(0);
//Print("RANAP parser catch exception: %s - %s - %hd\n", context.getErrorLocation(), e.getLocation(), e.errorCode);
}
return iRet;
}
int CRANAPptl::parse(unsigned char* pdata, int len)
{
int iRet = 0;
//@zh 20100820 bug fixed
if(NULL == pdata || len < 4) return -1;
SetProtocolType(MOD_RANAP);
//
Buffer* buffer = wrapBuffer((char*)(&pdata[0]), len, ALIGNED_PACKED_ENCODING_RULES);
if(buffer!=NULL)
{
struct RANAP_PDU pdu = {0}; //@zh 20100824 bug fixed
//解码程序会修改源数据 pdata ???
iRet = decode_RANAP_PDU(buffer, &pdu);
if(iRet==0)
{
//print_RANAP_PDU(&pdu, printf);
//printf("\n");
SetPrimitiveType(pdu.choice); //@zh 20100820 bug fixed
switch(pdu.choice)
{
case RANAP_PDU_initiatingMessage_chosen:
{
struct InitiatingMessage* pInitiatingMessage = &pdu.value.initiatingMessage;
SetMessageType(pInitiatingMessage->procedureCode); //@zh 20100820 bug fixed
switch(pInitiatingMessage->procedureCode)
{
case RANAP_RAB_ASSIGNMENT :// 0
{
struct RAB_AssignmentRequest* pRAB_AssignmentRequest = &pInitiatingMessage->value.rAB_AssignmentRequest;
iRet = parseRABAssignment(pRAB_AssignmentRequest);
}
break;
case RANAP_Iu_RELEASE :// 1
{
struct Iu_ReleaseCommand* pIu_ReleaseCommand = &pInitiatingMessage->value.iu_ReleaseCommand;
iRet = parseIuRelease(pIu_ReleaseCommand);
}
break;
case RANAP_RelocationPreparation :// 2
break;
case RANAP_RelocationResAllocation :// 3
break;
case RANAP_RelocationCancel :// 4
break;
case RANAP_SRNS_ContextTransfer :// 5
break;
case RANAP_SecurityNodeControl ://6
break;
case RANAP_DataVolumeReport ://7
break;
case RANAP_Reset ://9
break;
case RANAP_RAB_ReleaseRequest ://10
break;
case RANAP_Iu_ReleaseRequest ://11
break;
case RANAP_RelocationDetect ://12
break;
case RANAP_RelocationComplete ://13
break;
case RANAP_Paging ://14
{
struct Paging* pPaging = &pInitiatingMessage->value.paging;
iRet = parsePaging(pPaging);
}
break;
case RANAP_CommonID ://15
{
struct CommonID* pCommonID = &pInitiatingMessage->value.commonID;
iRet = parseCommonID(pCommonID);
}
break;
case RANAP_CN_InvokeTrace ://16
break;
case RANAP_LocationReportingControl ://17
break;
case RANAP_LocationReport ://18
break;
case RANAP_InitialUE_Message ://19
{
struct InitialUE_Message* pInitialUE_Message = &pInitiatingMessage->value.initialUE_Message;
iRet = parseInitialUEMessage(pInitialUE_Message);
}
break;
case RANAP_DirectTransfer ://20
{
struct DirectTransfer* pDirectTransfer = &pInitiatingMessage->value.directTransfer;
iRet = parseDirectTransfer(pDirectTransfer);
}
break;
case RANAP_OverloadControl ://21
break;
case RANAP_ErrorIndication ://22
break;
case RANAP_SRNS_DataForward ://23
break;
case RANAP_ForwardSRNS_Context ://24
break;
case RANAP_privateMessage ://25
break;
case RANAP_CN_DeactivateTrace ://26
break;
case RANAP_ResetResource ://27
break;
case RANAP_Relocation ://28
break;
case RANAP_RAB_ModifyRequest ://29
break;
case RANAP_LocationRelatedData ://30
break;
case RANAP_InformationTransfer ://31
break;
case RANAP_UESpecificInformation ://32
break;
case RANAP_UplinkInformationExchange ://33
break;
case RANAP_DirectInformationTransfer ://34
break;
case RANAP_MBMSSessionStart ://35
break;
case RANAP_MBMSSessionUpdate ://36
break;
case RANAP_MBMSSessionStop ://37
break;
case RANAP_MBMSUELinking ://38
break;
case RANAP_MBMSRegistration ://39
break;
case RANAP_MBMSCNDe_Registration_Procedure ://40
break;
case RANAP_MBMSRABEstablishmentIndication ://41
break;
case RANAP_MBMSRABRelease ://42
break;
case RANAP_enhancedRelocationComplete ://43
break;
case RANAP_enhancedRelocationCompleteConfirm ://44
break;
case RANAP_enhancedRelocation ://45
break;
case RANAP_SRVCCPreparation ://46
break;
default:
break;
}
}
break;
case RANAP_PDU_successfulOutcome_chosen:
{
struct SuccessfulOutcome* pSuccessfulOutcome = &pdu.value.successfulOutcome;
SetMessageType(pSuccessfulOutcome->procedureCode); //@zh 20100820 bug fixed
switch(pSuccessfulOutcome->procedureCode)
{
case RANAP_RelocationPreparation :// 2
break;
case RANAP_RelocationResAllocation :// 3
break;
case RANAP_DataVolumeReport ://7
break;
case RANAP_MBMSSessionStop ://37
break;
case RANAP_UplinkInformationExchange ://33
break;
case RANAP_LocationRelatedData ://30
break;
case RANAP_MBMSRABRelease ://42
break;
case RANAP_SRNS_ContextTransfer :// 5
break;
case RANAP_enhancedRelocation ://45
break;
case RANAP_RelocationCancel :// 4
break;
case RANAP_InformationTransfer ://31
break;
case RANAP_MBMSCNDe_Registration_Procedure ://40
break;
case RANAP_SecurityNodeControl ://6
break;
case RANAP_MBMSSessionStart ://35
break;
case RANAP_MBMSSessionUpdate ://36
break;
case RANAP_MBMSRegistration ://39
break;
case RANAP_enhancedRelocationComplete ://43
break;
case RANAP_ResetResource ://27
break;
case RANAP_Iu_RELEASE :// 1
{
struct Iu_ReleaseComplete* pIu_ReleaseComplete = &pSuccessfulOutcome->value.iu_ReleaseComplete;
}
break;
case RANAP_Reset ://9
break;
default:
break;
}
}
break;
case RANAP_PDU_unsuccessfulOutcome_chosen:
{
struct UnsuccessfulOutcome* pUnsuccessfulOutcome = &pdu.value.unsuccessfulOutcome;
SetMessageType(pUnsuccessfulOutcome->procedureCode); //@zh 20100820 bug fixed
switch(pUnsuccessfulOutcome->procedureCode)
{
case RANAP_MBMSSessionStart ://35
break;
case RANAP_InformationTransfer ://31
break;
case RANAP_MBMSRegistration ://39
break;
case RANAP_MBMSRABRelease ://42
break;
case RANAP_SecurityNodeControl ://6
break;
case RANAP_RelocationPreparation :// 2
break;
case RANAP_RelocationResAllocation :// 3
break;
case RANAP_UplinkInformationExchange ://33
break;
case RANAP_MBMSSessionUpdate ://36
break;
case RANAP_enhancedRelocationComplete ://43
break;
case RANAP_LocationRelatedData ://30
break;
default:
break;
}
}
break;
case RANAP_PDU_outcome_chosen:
{
struct Outcome* pOutcome = &pdu.value.outcome;
SetMessageType(pOutcome->procedureCode); //@zh 20100820 bug fixed
switch(pOutcome->procedureCode)
{
case RANAP_RAB_ASSIGNMENT :// 0
{
struct RAB_AssignmentResponse* pRAB_AssignmentResponse = &pOutcome->value.rAB_AssignmentResponse;
}
break;
/* @{procedureCode = 255} */
case RANAP_MBMSUELinking ://38
break;
default:
break;
}
}
break;
}
}
else
{
//printf("DeCode Error: %s\n", ASN_LIB_ERROR_STRING[iRet]);
iRet = -1;
}
free_RANAP_PDU(&pdu);
asn_free(buffer);
}
return iRet;
}
////////////////////////////////////////////////////////////////////////
///
/// Loads DirectX mesh file.
///
/// @param filename Filename to load.
///
/// @return success or failure.
///
////////////////////////////////////////////////////////////////////////
const VCNBool VCNDXMesh::LoadFromFile( const VCNString& filename )
{
VCND3D9* renderer = static_cast<VCND3D9*>( VCNRenderCore::GetInstance() );
LPDIRECT3DDEVICE9 d3dDevice = renderer->GetD3DDevice();
CComPtr<ID3DXMesh> systemMesh;
CComPtr<ID3DXBuffer> materialBuffer;
// Load the mesh from the specified file
//
DWORD numMaterials = 0;
HRESULT hr = D3DXLoadMeshFromX(filename.c_str(), D3DXMESH_SYSTEMMEM,
d3dDevice, NULL, &materialBuffer,NULL, &numMaterials, &systemMesh );
if ( FAILED(hr) )
return false;
// Load materials
//
D3DXMATERIAL* d3dxMaterials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
for (DWORD i = 0; i < numMaterials; ++i)
{
VCN_ASSERT_MSG( i == 0 || mMaterialID == kInvalidResID, VCNTXT("We do not support multiple material per meshes") );
// Create the texture if it exists - it may not
if (d3dxMaterials[i].pTextureFilename)
{
VCNString texturePath = VCNTXT("Textures/");
texturePath += VCN_A2W(d3dxMaterials[i].pTextureFilename);
// Check if the texture is already loaded
VCNResID texID = kInvalidResID;
VCND3D9Texture* resTexture = VCNResourceCore::GetInstance()->GetResource<VCND3D9Texture>(texturePath);
if (!resTexture)
{
LPDIRECT3DTEXTURE9 d3dTexture = NULL;
hr = D3DXCreateTextureFromFile(d3dDevice, texturePath.c_str(), &d3dTexture);
VCN_ASSERT_MSG( SUCCEEDED(hr), _T("Can't load texture [%s]"), texturePath.c_str() );
resTexture = new VCND3D9Texture( d3dTexture );
resTexture->SetName( texturePath );
texID = VCNResourceCore::GetInstance()->AddResource( texturePath, resTexture );
}
else
{
texID = resTexture->GetResourceID();
}
VCNMaterial* material = new VCNMaterial();
material->SetName( VCNString(VCNTXT("material_dx_mesh_")) + filename );
material->SetAmbientColor( VCNColor((const VCNFloat*)&d3dxMaterials[i].MatD3D.Ambient) );
material->SetDiffuseColor( VCNColor((const VCNFloat*)&d3dxMaterials[i].MatD3D.Diffuse) );
material->SetSpecularColor( VCNColor((const VCNFloat*)&d3dxMaterials[i].MatD3D.Specular) );
material->SetSpecularPower( d3dxMaterials[i].MatD3D.Power );
VCNEffectParamSet& params = material->GetEffectParamSet();
params.SetEffectID( eidLitTextured );
params.AddResource( VCNTXT("DiffuseTexture"), texID );
// Add material as a resource.
mMaterialID = VCNResourceCore::GetInstance()->AddResource( material->GetName(), material );
}
}
// Optimize the mesh if possible
//
const VCNUInt faceCount = systemMesh->GetNumFaces();
DWORD* adjac = new DWORD[faceCount*3];
hr = systemMesh->GenerateAdjacency(0.5f, adjac);
hr = systemMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, adjac, NULL, NULL, NULL);
// Calculate Tangent and Binormal
hr = D3DXComputeTangentFrameEx(systemMesh,
D3DDECLUSAGE_TEXCOORD, 0,
D3DDECLUSAGE_TANGENT, 0,
D3DDECLUSAGE_BINORMAL, 0,
D3DDECLUSAGE_NORMAL, 0,
D3DXTANGENT_DONT_ORTHOGONALIZE | D3DXTANGENT_WEIGHT_BY_AREA,
adjac,
-1.01f, -0.01f, -1.01f,
&systemMesh,
NULL);
delete [] adjac;
// Load caches
//
const VCNUInt vertexCount = systemMesh->GetNumVertices();
const DWORD meshFVF = systemMesh->GetFVF();
const DWORD stride = D3DXGetFVFVertexSize( meshFVF );
const DWORD positionStride = D3DXGetFVFVertexSize( D3DFVF_XYZ );
const DWORD normalStride = D3DXGetFVFVertexSize( D3DFVF_NORMAL );
const DWORD diffuseStride = D3DXGetFVFVertexSize( D3DFVF_DIFFUSE );
const DWORD textureStride = D3DXGetFVFVertexSize( D3DFVF_TEX1 );
VCNFloat* vtPositionBufStart = new VCNFloat[vertexCount * kCacheStrides[VT_POSITION]];
VCNFloat* vtNormalBufStart = new VCNFloat[vertexCount * kCacheStrides[VT_LIGHTING]];
VCNFloat* vtTextureBufStart = new VCNFloat[vertexCount * kCacheStrides[VT_DIFFUSE_TEX_COORDS]];
VCNFloat* vtPositionBuf = vtPositionBufStart;
VCNFloat* vtNormalBuf = vtNormalBufStart;
VCNFloat* vtTextureBuf = vtTextureBufStart;
BYTE* vbptr = NULL;
systemMesh->LockVertexBuffer(D3DLOCK_READONLY, (LPVOID*)&vbptr);
for(VCNUInt i = 0; i < vertexCount; ++i)
{
if ( meshFVF == (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1) )
{
// Read position
D3DXVECTOR3* pos = (D3DXVECTOR3*)vbptr;
*vtPositionBuf = pos->x; vtPositionBuf++;
*vtPositionBuf = pos->y; vtPositionBuf++;
*vtPositionBuf = pos->z; vtPositionBuf++;
// Read normal
D3DXVECTOR3* normal = (D3DXVECTOR3*)(vbptr + positionStride);
*vtNormalBuf = normal->x; vtNormalBuf++;
*vtNormalBuf = normal->y; vtNormalBuf++;
*vtNormalBuf = normal->z; vtNormalBuf++;
// Set default diffuse color
std::fill(vtNormalBuf, vtNormalBuf+3, 1.0f);
vtNormalBuf += 3;
float* texCoords = (float*)(vbptr + positionStride + normalStride);
*vtTextureBuf = texCoords[0]; vtTextureBuf++;
*vtTextureBuf = texCoords[1]; vtTextureBuf++;
vbptr += stride;
}
else
{
VCN_ASSERT_FAIL( VCNTXT("Mesh FVF not supported [FVF(%d) stride = %d]"), meshFVF, stride );
}
}
systemMesh->UnlockVertexBuffer();
VCNResID positionCache = renderer->CreateCache(VT_POSITION, vtPositionBufStart, vertexCount * kCacheStrides[VT_POSITION]);
VCNResID lightingCache = renderer->CreateCache(VT_LIGHTING, vtNormalBufStart, vertexCount * kCacheStrides[VT_LIGHTING]);
VCNResID textureCache = renderer->CreateCache(VT_DIFFUSE_TEX_COORDS, vtTextureBufStart, vertexCount * kCacheStrides[VT_DIFFUSE_TEX_COORDS]);
SetCacheID(VT_POSITION, positionCache);
SetCacheID(VT_LIGHTING, lightingCache);
SetCacheID(VT_DIFFUSE_TEX_COORDS, textureCache);
delete [] vtPositionBufStart;
delete [] vtNormalBufStart;
delete [] vtTextureBufStart;
VCNUShort* ibptr = NULL;
VCNUShort* indices = new VCNUShort[faceCount * 3];
systemMesh->LockIndexBuffer(D3DLOCK_READONLY, (LPVOID*)&ibptr);
for(VCNUInt i = 0; i < systemMesh->GetNumFaces(); i++)
{
indices[(i * 3) + 0] = *(ibptr++);
indices[(i * 3) + 1] = *(ibptr++);
indices[(i * 3) + 2] = *(ibptr++);
}
systemMesh->UnlockIndexBuffer();
VCNResID indexCacheID = renderer->CreateCache(VT_INDEX, indices, faceCount * 3 * kCacheStrides[VT_INDEX]);
SetFaceCache(indexCacheID);
SetFaceCount(faceCount);
SetPrimitiveType(PT_TRIANGLELIST);
delete [] indices;
// Compute bounding sphere
if ( !ComputeBoundingSphere(systemMesh) )
return false;
return true;
}
