RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Separated class VertexElementArray into its own file.

This commit is contained in:
aignacio_sf 2006-01-23 19:06:37 +00:00
parent 49c678b11d
commit 6481cb76b1
7 changed files with 482 additions and 420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
panda/src/dxgsg9/Sources.pp
View File

@ -32,6 +32,7 @@
dxGraphicsDevice9.h \
dxShaderContext9.h \
../display/lru.h \
vertexElementArray.h
#define INCLUDED_SOURCES \
config_dxgsg9.cxx \
@ -43,6 +44,7 @@
wdxGraphicsPipe9.cxx \
wdxGraphicsWindow9.cxx \
wdxGraphicsBuffer9.cxx \
dxShaderContext9.cxx
dxShaderContext9.cxx \
vertexElementArray.cxx
#end lib_target

60
panda/src/dxgsg9/dxGraphicsStateGuardian9.h
View File

@ -39,6 +39,7 @@ typedef D3DVERTEXELEMENT9 DIRECT_3D_VERTEX_ELEMENT;
typedef LPDIRECT3DDEVICE9 DIRECT_3D_DEVICE;
typedef LPDIRECT3DVERTEXDECLARATION9 DIRECT_3D_VERTEX_DECLARATION;
#include "vertexElementArray.h"
#include "dxShaderContext9.h"
@ -371,63 +372,4 @@ private:
#include "dxGraphicsStateGuardian9.I"
enum
{
VS_END = 0,
VS_POSITION_XYZ,
VS_POSITION_XYZW,
VS_NORMAL,
VS_DIFFUSE,
VS_SPECULAR,
VS_TEXTURE_U,
VS_TEXTURE_UV,
VS_TEXTURE_UVW,
VS_TANGENT,
VS_BINORMAL,
VS_ERROR,
VS_TOTAL_TYPES
};
typedef struct
{
int id; // this is VS_XXXXX
int index;
int stream;
int offset;
}
VERTEX_ELEMENT_TYPE;
class VertexElementArray
{
public:
VertexElementArray (int maximum_vertex_elements);
~VertexElementArray ( );
int set_vertex_element_offset (int vertex_element_index, int offset);
void add_position_xyz_vertex_element (int stream_index);
void add_position_xyzw_vertex_element (int stream_index);
void add_normal_vertex_element (int stream_index);
void add_binormal_vertex_element (int stream_index);
void add_tangent_vertex_element (int stream_index);
void add_diffuse_color_vertex_element (int stream_index);
void add_specular_color_vertex_element (int stream_index);
void add_u_vertex_element (int stream_index);
void add_uv_vertex_element (int stream_index);
void add_uvw_vertex_element (int stream_index);
int add_end_vertex_element (void);
int offset;
int total_elements;
int maximum_vertex_elements;
int vertex_element_type_counter_array [VS_TOTAL_TYPES];
DIRECT_3D_VERTEX_ELEMENT *vertex_element_array;
VERTEX_ELEMENT_TYPE *vertex_element_type_array;
};
#endif

358
panda/src/dxgsg9/dxShaderContext9.cxx
View File

@ -21,364 +21,6 @@
TypeHandle CLP(ShaderContext)::_type_handle;
VertexElementArray::VertexElementArray (int maximum_vertex_elements)
{
this -> offset = 0;
this -> total_elements = 0;
this -> maximum_vertex_elements = maximum_vertex_elements;
this -> vertex_element_array = new DIRECT_3D_VERTEX_ELEMENT [maximum_vertex_elements];
this -> vertex_element_type_array = new VERTEX_ELEMENT_TYPE [maximum_vertex_elements];
memset (this -> vertex_element_type_counter_array, 0, VS_TOTAL_TYPES * sizeof (int));
}
VertexElementArray::~VertexElementArray ( )
{
delete this -> vertex_element_array;
delete this -> vertex_element_type_array;
}
int VertexElementArray::set_vertex_element_offset (int vertex_element_index, int offset)
{
int state;
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
if (vertex_element_index >= 0 && vertex_element_index < this -> total_elements)
{
vertex_element = &this -> vertex_element_array [vertex_element_index];
vertex_element -> Offset = offset;
state = true;
}
return state;
}
void VertexElementArray::add_position_xyz_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_POSITION_XYZ;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_POSITION;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_position_xyzw_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_POSITION_XYZW;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT4;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_POSITION;
vertex_element -> UsageIndex = 0;
this -> offset += 16;
this -> total_elements++;
}
}
void VertexElementArray::add_normal_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_NORMAL;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_NORMAL;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_binormal_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_BINORMAL;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_BINORMAL;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_tangent_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TANGENT;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TANGENT;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_diffuse_color_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_DIFFUSE;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_D3DCOLOR;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_COLOR;
vertex_element -> UsageIndex = 0;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_specular_color_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_SPECULAR;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_D3DCOLOR;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_COLOR;
vertex_element -> UsageIndex = 1;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_u_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_U;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT1;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_uv_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_UV;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT2;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 8;
this -> total_elements++;
}
}
void VertexElementArray::add_uvw_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_UVW;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
int VertexElementArray::add_end_vertex_element (void)
{
int add;
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
add = FALSE;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_END;
vertex_element -> Stream = 0xFF;
vertex_element -> Type = D3DDECLTYPE_UNUSED;
add = TRUE;
}
return add;
}
////////////////////////////////////////////////////////////////////
// Function: DXShaderContext9::Constructor
// Access: Public

1
panda/src/dxgsg9/dxShaderContext9.h
View File

@ -20,7 +20,6 @@
#define DXSHADERCONTEXT9_H
#include "dtool_config.h"
#include "dxGraphicsStateGuardian9.h"
#include "pandabase.h"
#ifdef HAVE_CGDX9
#include "Cg/cg.h"

2
panda/src/dxgsg9/dxgsg9_composite1.cxx
View File

@ -9,4 +9,4 @@
#include "wdxGraphicsWindow9.cxx"
#include "dxGraphicsDevice9.cxx"
#include "wdxGraphicsBuffer9.cxx"
#include "vertexElementArray.cxx"

381
panda/src/dxgsg9/vertexElementArray.cxx Normal file
View File

@ -0,0 +1,381 @@
// Filename: vertexElementArray.cxx
// Created by: aignacio (Jan06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2006, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
#include "dxGraphicsStateGuardian9.h"
#include "vertexElementArray.h"
VertexElementArray::VertexElementArray (int maximum_vertex_elements)
{
this -> offset = 0;
this -> total_elements = 0;
this -> maximum_vertex_elements = maximum_vertex_elements;
this -> vertex_element_array = new DIRECT_3D_VERTEX_ELEMENT [maximum_vertex_elements];
this -> vertex_element_type_array = new VERTEX_ELEMENT_TYPE [maximum_vertex_elements];
memset (this -> vertex_element_type_counter_array, 0, VS_TOTAL_TYPES * sizeof (int));
}
VertexElementArray::~VertexElementArray ( )
{
delete this -> vertex_element_array;
delete this -> vertex_element_type_array;
}
int VertexElementArray::set_vertex_element_offset (int vertex_element_index, int offset)
{
int state;
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
if (vertex_element_index >= 0 && vertex_element_index < this -> total_elements)
{
vertex_element = &this -> vertex_element_array [vertex_element_index];
vertex_element -> Offset = offset;
state = true;
}
return state;
}
void VertexElementArray::add_position_xyz_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_POSITION_XYZ;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_POSITION;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_position_xyzw_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_POSITION_XYZW;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT4;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_POSITION;
vertex_element -> UsageIndex = 0;
this -> offset += 16;
this -> total_elements++;
}
}
void VertexElementArray::add_normal_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_NORMAL;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_NORMAL;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_binormal_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_BINORMAL;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_BINORMAL;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_tangent_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TANGENT;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TANGENT;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
void VertexElementArray::add_diffuse_color_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_DIFFUSE;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_D3DCOLOR;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_COLOR;
vertex_element -> UsageIndex = 0;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_specular_color_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_SPECULAR;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_D3DCOLOR;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_COLOR;
vertex_element -> UsageIndex = 1;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_u_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_U;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT1;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 4;
this -> total_elements++;
}
}
void VertexElementArray::add_uv_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_UV;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT2;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 8;
this -> total_elements++;
}
}
void VertexElementArray::add_uvw_vertex_element (int stream_index)
{
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_TEXTURE_UVW;
vertex_element_type -> index = vertex_element_type_counter_array [vertex_element_type -> id];
vertex_element_type_counter_array [vertex_element_type -> id]++;
vertex_element -> Stream = stream_index;
vertex_element -> Offset = this -> offset;
vertex_element -> Type = D3DDECLTYPE_FLOAT3;
vertex_element -> Method = D3DDECLMETHOD_DEFAULT;
vertex_element -> Usage = D3DDECLUSAGE_TEXCOORD;
vertex_element -> UsageIndex = 0;
this -> offset += 12;
this -> total_elements++;
}
}
int VertexElementArray::add_end_vertex_element (void)
{
int add;
DIRECT_3D_VERTEX_ELEMENT *vertex_element;
VERTEX_ELEMENT_TYPE *vertex_element_type;
add = FALSE;
if (this -> total_elements < this -> maximum_vertex_elements)
{
vertex_element = &this -> vertex_element_array [this -> total_elements];
memset (vertex_element, 0, sizeof (DIRECT_3D_VERTEX_ELEMENT));
vertex_element_type = &this -> vertex_element_type_array [this -> total_elements];
memset (vertex_element_type, 0, sizeof (VERTEX_ELEMENT_TYPE));
vertex_element_type -> id = VS_END;
vertex_element -> Stream = 0xFF;
vertex_element -> Type = D3DDECLTYPE_UNUSED;
add = TRUE;
}
return add;
}

96
panda/src/dxgsg9/vertexElementArray.h Normal file
View File

@ -0,0 +1,96 @@
// Filename: vertexElementArray.h
// Created by: aignacio (Jan06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2006, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
#ifndef VERTEX_ELEMENT_ARRAY_H
#define VERTEX_ELEMENT_ARRAY_H
enum
{
VS_END = 0,
VS_POSITION_XYZ,
VS_POSITION_XYZW,
VS_NORMAL,
VS_DIFFUSE,
VS_SPECULAR,
VS_TEXTURE_U,
VS_TEXTURE_UV,
VS_TEXTURE_UVW,
VS_TANGENT,
VS_BINORMAL,
VS_ERROR,
VS_TOTAL_TYPES
};
typedef struct
{
int id; // this is VS_XXXXX
int index;
int stream;
int offset;
}
VERTEX_ELEMENT_TYPE;
////////////////////////////////////////////////////////////////////
// Class : VertexElementArray
// Description : This class gives the ability for a user-friendly way
// of creating a vertex declaration for DirectX 9.
// Since a vertex shader has a fixed input, the vertex
// element array can be cached so that a new vertex
// declaration for different vertex buffers can be
// quickly created. Be sure to call
// add_end_vertex_element ( ) when finished creating a
// vertex element array.
// VERTEX_ELEMENT_TYPE is used for a simplified mapping
// of vertex buffer data to vertex shader inputs.
// This class is used with DXShaderContext9 and in
// conjunction with DXVertexBufferContext9.
////////////////////////////////////////////////////////////////////
class VertexElementArray
{
public:
VertexElementArray (int maximum_vertex_elements);
~VertexElementArray ( );
int set_vertex_element_offset (int vertex_element_index, int offset);
void add_position_xyz_vertex_element (int stream_index);
void add_position_xyzw_vertex_element (int stream_index);
void add_normal_vertex_element (int stream_index);
void add_binormal_vertex_element (int stream_index);
void add_tangent_vertex_element (int stream_index);
void add_diffuse_color_vertex_element (int stream_index);
void add_specular_color_vertex_element (int stream_index);
void add_u_vertex_element (int stream_index);
void add_uv_vertex_element (int stream_index);
void add_uvw_vertex_element (int stream_index);
int add_end_vertex_element (void);
int offset;
int total_elements;
int maximum_vertex_elements;
int vertex_element_type_counter_array [VS_TOTAL_TYPES];
DIRECT_3D_VERTEX_ELEMENT *vertex_element_array;
VERTEX_ELEMENT_TYPE *vertex_element_type_array;
};
#endif