2014年8月26日星期二（DEMO8-9加载COB模型）

2023-11-03

步骤

1读取文件开头第一行

2读取名称、中心位置、X轴、Y轴和Z轴，用来定义局部矩阵

3读取局部坐标到世界坐标的变换矩阵

4,读取World Vertices行，并按照x,y,z顺序读取顶点列表

5,读取Texture Vertices行，然后读取每个顶点的<u,v>纹理坐标

6,读取Face行，然后读取每个多边形面（这里用三角形面），格式为 Face verts 3 flags 标记 mat 材质号，材质号说明了该面的材质。接下来读取多边形面本身，顶点索引格式为<该面三角形顶点的索引，纹理坐标>

7，加载材质，有alpha透明度，反射系数和着色方法。

Cob模型多边形有2种，一个是普通彩色多边形(即使用固定、恒定、Gouraud或Phong着色)，Shader colors : color

Shader name:”Plain color”( plain )

另外一个就是贴纹理的多边形，

Shader colors:texture map

Shader name:”xxxxxx”(xxxxxx)

其中,xxxxxx代表设置的着色系统，如”constant”,”matte”,”plastic”,”phong”,”texture map”

先看看有什么区别，

首先与3DSMAX相比，多了个纹理。

并保留了局部矩阵和世界矩阵。

开始模式也变了：

if( parser.Pattern_Match( parser.buffer, "['Name'][s>0]" ) )

最明显的还是多了局部坐标和世界坐标

//计算临时变量

VECTOR4D temp_vector;

//现在使用局部和世界变换的COB格式解码

if( vertex_flags & VERTEX_FLAGS_TRANSFORM_LOCAL )

{

math2.Mat_Mul_VECTOR4D_4X4( & obj->vlist_local[vertex], &mat_local, &temp_vector );

math2.VECTOR4D_COPY( & obj->vlist_local[vertex]. & temp_vector );

}

if( vertex_flags & VERTEX_FLAGS_TRANSFORM_LOCAL_WORLD )

{

math2.Mat_Mul_VECTOR4D_4X4( & obj->vlist_local[vertex], &mat_world, &temp_vector );

math2.VECTOR4D_COPY( & obj->vlist_local[vertex]. & temp_vector );

}

现在继续进行，cob 模型加入了材质

MATV1 materials[MAX_MATERIALS];

目前还没有加上MATV1的定义，回过头来看8.2.2定义材质1节，材质的提出，是替代以前用来记录多边形属性字段信息，也就是说，以后不在多边形中存储这些数据了，而是定义大量的材质。引擎根据多边形中的存储的ID或指针来找到相应的材质，并根据该材质而不是多边形的内部信息来渲染多边形。

再添加个材质类。

#pragma once

#include "common.h"

//材质属性

#define MATV1_ATTR_2SIDED 0x0001

#define MATV1_ATTR_TRANSPARENT 0x0002

#define MATV1_ATTR_8BITCOLOR 0x0004

#define MATV1_ATTR_RGB16 0x0008

#define MATV1_ATTR_RGB24 0x0010

#define MATV1_ATTR_SHADE_MODE_CONSTANT 0x0020

#define MATV1_ATTR_SHADE_MODE_EMISSIVE 0x0020 //别名

#define MATV1_ATTR_SHADE_MODE_FLAT 0x0040

#define MATV1_ATTR_SHADE_MODE_GOURAUD 0x0080

#define MATV1_ATTR_SHADE_MODE_FASTPHONG 0x0100

#define MATV1_ATTR_SHADE_MODE_TEXTURE 0x0200

//材质状态

#define MATV1_STATE_ACTIVE 0x0001

#define MAX_MATERIALS 256

//材质数据结构

typedef struct MATV1_TYP

{

int state; //材质的状态

int id; //材质id,指向材质数组的索引

char name[64]; //材质名称

int attr; //属性，着色模式、着色方法、环境、纹理以及其他特殊标记

RGBAV1 color; //材质颜色

float ka, kd, ks, power; //对环境光、散射光和镜面反射光的反射系数和镜面反射指数

RGBAV1 ra, rd, rs; //预先计算得到的颜色和反射系数的积

char texture_file[80]; //包含纹理的文件的位置

BITMAP_IMAGE texture; //纹理图

int iaux1, iaux2;

float faux1, faux2;

void * ptr;

}MATV1, * MATV1_PTR;

class DDRAW_Material

{

public:

DDRAW_Material(void);

~DDRAW_Material(void);

};

突然发现，有个变量，就是材质数num_materials没有赋给初值

if( parser.Pattern_Match( parser.buffer, "['rgb'][f][f][f]" ) )

{

materials[material_index + num_materials].color.r = ( int ) ( parser.pfloats[0] * 255 + 0.5 );

materials[material_index + num_materials].color.g = ( int ) ( parser.pfloats[1] * 255 + 0.5 );

materials[material_index + num_materials].color.b = ( int ) ( parser.pfloats[2] * 255 + 0.5 );

break;

}

这样，先在函数中加上个变量

int num_materials = 0;

具体核心代码如下：

int ddraw_liushuixian::Load_OBJECT4DV1_COB( ddraw_math math2, OBJECT4DV1_PTR obj, char * filename, VECTOR4D_PTR scale, VECTOR4D_PTR pos, VECTOR4D_PTR rot, int vertex_flags)

{

CPARSERV1 parser;

char seps[16];

char token_buffer[256]; //缓冲区

char * token; //指向要分析的物体数据文本的指针

int r, g, b;

int num_materials = 0;

int material_index = 0;

VERTEX2DF texture_vertices[1024]; //纹理区域

int num_texture_vertices = 0;

MATRIX4X4 mat_local, mat_world; //局部坐标系和世界坐标系

MATV1 materials[MAX_MATERIALS];

//矩阵归一化

math2.Mat_IDENTITY_4X4( & mat_local );

math2.Mat_IDENTITY_4X4( & mat_world );

//先找到物体描述符

//第一步清空和初始化OBJ

memset( obj, 0, sizeof(OBJECT4DV1) );

//将物体状态设置为可见和活动的

obj->state = OBJECT4DV1_STATE_ACTIVE | OBJECT4DV1_STATE_VISIBLE;

if ( pos )

{

//设置物体的位置

obj->world_pos.x = pos->x;

obj->world_pos.y = pos->y;

obj->world_pos.z = pos->z;

obj->world_pos.w = pos->w;

}

else

{

//设置物体的位置

obj->world_pos.x = 0;

obj->world_pos.y = 0;

obj->world_pos.z = 0;

obj->world_pos.w = 1;

}

//第步，读取文件

parser.Open( filename );

//第步，读取物体描述符

while ( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

//检测模式

if( parser.Pattern_Match( parser.buffer, "['Name'][s>0]" ) )

{

strcpy( obj->name, parser.pstrings[1] );

break;

}

//第步，得到局部变换和世界变换并保存

while( 1 )

{

//下一行，寻找中心点,

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "['center'][f][f][f]" ) )

{

mat_local.M[3][0] = -parser.pfloats[0]; //中心点X

mat_local.M[3][1] = -parser.pfloats[1]; //中心点Y

mat_local.M[3][2] = -parser.pfloats[2]; //中心点Z

//寻找x轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "['x']['axis'][f][f][f]" );

mat_local.M[0][0] = parser.pfloats[0]; //rxx

mat_local.M[1][0] = parser.pfloats[1]; //rxy

mat_local.M[2][0] = parser.pfloats[2]; //rxz

//寻找y轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "['y']['axis'][f][f][f]" );

mat_local.M[0][1] = parser.pfloats[0]; //ryx

mat_local.M[1][1] = parser.pfloats[1]; //ryy

mat_local.M[2][1] = parser.pfloats[2]; //ryz

//寻找z轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "['z']['axis'][f][f][f]" );

mat_local.M[0][2] = parser.pfloats[0]; //rzx

mat_local.M[1][2] = parser.pfloats[1]; //rzy

mat_local.M[2][2] = parser.pfloats[2]; //rzz

break;

}

//现在是"Transform"字段

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "['Transform']" ) )

{

//寻找x轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "[f][f][f]" );

mat_world.M[0][0] = parser.pfloats[0]; //rxx

mat_world.M[1][0] = parser.pfloats[1]; //rxy

mat_world.M[2][0] = parser.pfloats[2]; //rxz

//寻找y轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "[f][f][f]" );

mat_world.M[0][1] = parser.pfloats[0]; //ryx

mat_world.M[1][1] = parser.pfloats[1]; //ryy

mat_world.M[2][1] = parser.pfloats[2]; //ryz

//寻找z轴平移矩阵

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.Pattern_Match( parser.buffer, "[f][f][f]" );

mat_world.M[0][2] = parser.pfloats[0]; //rzx

mat_world.M[1][2] = parser.pfloats[1]; //rzy

mat_world.M[2][2] = parser.pfloats[2]; //rzz

break;

}

//第步，得到我图的顶点和边数目

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

//下一行，寻找Tri-Mesh,Vertices，提取顶点数目

if( parser.Pattern_Match( parser.buffer, "['World']['Vertices'][i]" ) )

{

obj->num_vertices = parser.pints[0];

break;

}

//第步：加载顶点列表

//现在读取顶点列表，格式"Vertex:d X:d.d Y:d.d Z:d.d"

for( int vertex = 0; vertex < obj->num_vertices; vertex ++ )

{

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "[f][f][f]" ) )

{

obj->vlist_local[vertex].x = parser.pfloats[0];

obj->vlist_local[vertex].y = parser.pfloats[1];

obj->vlist_local[vertex].z = parser.pfloats[2];

obj->vlist_local[vertex].w = 1;

//计算临时变量

VECTOR4D temp_vector;

//现在使用局部和世界变换的COB格式解码

if( vertex_flags & VERTEX_FLAGS_TRANSFORM_LOCAL )

{

math2.Mat_Mul_VECTOR4D_4X4( & obj->vlist_local[vertex], &mat_local, &temp_vector );

math2.VECTOR4D_COPY( & obj->vlist_local[vertex], & temp_vector );

}

if( vertex_flags & VERTEX_FLAGS_TRANSFORM_LOCAL_WORLD )

{

math2.Mat_Mul_VECTOR4D_4X4( & obj->vlist_local[vertex], &mat_world, &temp_vector );

math2.VECTOR4D_COPY( & obj->vlist_local[vertex], & temp_vector );

}

//根据标志位来进行相应的旋转

float temp_f;

if( vertex_flags & VERTEX_FLAGS_INVERT_X )

obj->vlist_local[vertex].x = - obj->vlist_local[vertex].x;

if( vertex_flags & VERTEX_FLAGS_INVERT_Y )

obj->vlist_local[vertex].y = - obj->vlist_local[vertex].y;

if( vertex_flags & VERTEX_FLAGS_INVERT_Z )

obj->vlist_local[vertex].z = - obj->vlist_local[vertex].z;

if( vertex_flags & VERTEX_FLAGS_SWAP_YZ )

SWAP( obj->vlist_local[vertex].y, obj->vlist_local[vertex].z, temp_f );

if( vertex_flags & VERTEX_FLAGS_SWAP_XZ )

SWAP( obj->vlist_local[vertex].x, obj->vlist_local[vertex].z, temp_f );

if( vertex_flags & VERTEX_FLAGS_SWAP_XY )

SWAP( obj->vlist_local[vertex].x, obj->vlist_local[vertex].y, temp_f );

//放缩

if( scale )

{

obj->vlist_local[vertex].x *= scale->x;

obj->vlist_local[vertex].y *= scale->y;

obj->vlist_local[vertex].z *= scale->z;

}

break;

}

//计算平均和最大半径

Compute_OBJECT4DV1_RADIUS( obj );

//8,得到纹理顶点数目

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

//下一行，寻找Tri-Mesh,Vertices，提取顶点数目

if( parser.Pattern_Match( parser.buffer, "['Texture']['Vertices'][i]" ) )

{

num_texture_vertices = parser.pints[0];

break;

}

//第步：加载纹理UV列表

//现在读取顶点列表，格式"d.d.d.d"

for( int vertex = 0; vertex < obj->num_vertices; vertex ++ )

{

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "[f][f]" ) )

{

texture_vertices[vertex].x = parser.pfloats[0];

texture_vertices[vertex].y = parser.pfloats[1];

break;

}

int poly_material[OBJECT4DV1_MAX_POLYS];

int material_index_referenced[MAX_MATERIALS];

memset( material_index_referenced, 0, sizeof( material_index_referenced ) );

//第步，加载面

while( 1 )

{

if( ! parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS ) )

{

return ( 0 );

}

if( parser.Pattern_Match( parser.buffer, "['Faces'][i]" ) )

{

obj->num_polys = parser.pints[0];

break;

}

int poly_surface_desc = 0;

int poly_num_verts = 0;

int num_materials_object = 0;

for( int poly = 0; poly < obj->num_polys; poly++ )

{

while ( 1 )

{

if( ! parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS ) )

{

return ( 0 );

}

if( parser.Pattern_Match( parser.buffer, "['Face']['verts'][i]['flags'][i]['mat'][i]" ) )

{

poly_material[poly] = parser.pints[2];

if( material_index_referenced[poly_material[poly]] == 0 )

{

material_index_referenced[poly_material[poly]] = 1;

num_materials_object++;

}

if( parser.pints[0] != 3 )

{

return 0;

}

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.ReplaceChars( parser.buffer, parser.buffer, ",<>",' ' );

parser.Pattern_Match( parser.buffer, "[i][i][i][i][i][i]" );

if( vertex_flags & VERTEX_FLAGS_INVERT_WINDING_ORDER )

{

poly_num_verts = 3;

obj->plist[poly].vert[0] = parser.pints[4];

obj->plist[poly].vert[1] = parser.pints[2];

obj->plist[poly].vert[2] = parser.pints[0];

}

else

{

poly_num_verts = 3;

obj->plist[poly].vert[0] = parser.pints[0];

obj->plist[poly].vert[1] = parser.pints[2];

obj->plist[poly].vert[2] = parser.pints[4];

}

obj->plist[poly].vlist = obj->vlist_local;

obj->plist[poly].state = POLY4DV1_STATE_ACTIVE;

break;

}

//现在寻找材质

for( int curr_material = 0; curr_material < num_materials_object; curr_material++ )

{

// 寻找材质头"mat# ddd

while ( 1 )

{

if( ! parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS ) )

{

return ( 0 );

}

if( parser.Pattern_Match( parser.buffer, "['mat#'][i]" ) )

{

material_index = parser.pints[0];

while( 1 )

{

if( ! parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS ) )

{

return ( 0 );

}

parser.ReplaceChars( parser.buffer,parser.buffer, ",", ' ', 1 );

if( parser.Pattern_Match( parser.buffer, "['rgb'][f][f][f]" ) )

{

materials[material_index + num_materials].color.r = ( int ) ( parser.pfloats[0] * 255 + 0.5 );

materials[material_index + num_materials].color.g = ( int ) ( parser.pfloats[1] * 255 + 0.5 );

materials[material_index + num_materials].color.b = ( int ) ( parser.pfloats[2] * 255 + 0.5 );

break;

}

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "['alpha'][f]['ka'][f]['ks'][f]['exp'][f]" ) )

{

materials[material_index + num_materials].color.a = ( UCHAR ) ( parser.pfloats[0] * 255 + 0.5 );

materials[material_index + num_materials].ka = parser.pfloats[1];

materials[material_index + num_materials].kd = 1;

materials[material_index + num_materials].ks = parser.pfloats[2];

materials[material_index + num_materials].power = parser.pfloats[3];

//预先计算材质的反射系数

for( int rgb_index = 0; rgb_index < 3; rgb_index ++ )

{

//环境光反射系统

materials[material_index + num_materials].ra.rgba_M[rgb_index] =

( ( UCHAR ) ( materials[material_index + num_materials].ka *

( float )materials[material_index + num_materials].color.rgba_M[rgb_index] + 0.5 ) );

//散射光

materials[material_index + num_materials].rd.rgba_M[rgb_index] =

( ( UCHAR ) ( materials[material_index + num_materials].kd *

( float )materials[material_index + num_materials].color.rgba_M[rgb_index] + 0.5 ) );

//镜面光反射系数

materials[material_index + num_materials].rs.rgba_M[rgb_index] =

(( UCHAR ) ( materials[material_index + num_materials].ks *

( float )materials[material_index + num_materials].color.rgba_M[rgb_index] + 0.5 ) );

}

break;

}

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "['Shader']['class:']['color']" ) )

{

break;

}

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.ReplaceChars( parser.buffer, parser.buffer, "\"",' ', 1 );

if( parser.Pattern_Match( parser.buffer, "['Shader']['name:']['plain']['color']" ) )

{

break;

}

if( parser.Pattern_Match( parser.buffer, "['Shader']['name:']['texture']['map']" ) )

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_TEXTURE );

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.ReplaceChars( parser.buffer, parser.buffer, "\"",' ', 1 );

if( parser.Pattern_Match( parser.buffer, "['file']['name:']['string'][s>0]" ) )

{

parser.ReplaceChars( parser.pstrings[3], parser.pstrings[3], "\\", '/', 1 );

strcpy( materials[material_index + num_materials].texture_file, parser.pstrings[3] );

break;

}

break;

}

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

if( parser.Pattern_Match( parser.buffer, "['Shader']['class:']['reflectance']" ) )

{

break;

}

while( 1 )

{

parser.Getline( PARSER_STRIP_EMPTY_LINES | PARSER_STRIP_WS_ENDS );

parser.ReplaceChars( parser.buffer, parser.buffer, "\"", ' ', 1 );

if( parser.Pattern_Match( parser.buffer, "['Shader']['name:'][s>0]" ) )

{

if( strcmp( parser.pstrings[2], "constant" ) == 0 )

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_CONSTANT );

}

else

if( strcmp( parser.pstrings[2], "matte" ) == 0 )

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_FLAT );

}

else

if( strcmp( parser.pstrings[2], "plastic" ) == 0 )

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_GOURAUD );

}

else

if( strcmp( parser.pstrings[2], "phong" ) == 0 )

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_FASTPHONG );

}

else

{

SET_BIT( materials[material_index + num_materials].attr, MATV1_ATTR_SHADE_MODE_FLAT );

}

break;

}

break;

}

for( int curr_poly = 0; curr_poly < obj->num_polys; curr_poly++ )

{

poly_material[curr_poly] = poly_material[curr_poly] + num_materials;

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_RGB16 );

obj->plist[curr_poly].color = _RGB16BIT565( materials[poly_material[curr_poly]].color.r,

materials[poly_material[curr_poly]].color.g,

materials[poly_material[curr_poly]].color.b );

if( materials[poly_material[curr_poly]].attr & MATV1_ATTR_SHADE_MODE_CONSTANT )

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_CONSTANT );

}

else

if( materials[poly_material[curr_poly]].attr & MATV1_ATTR_SHADE_MODE_FLAT )

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_FLAT );

}

else

if( materials[poly_material[curr_poly]].attr & MATV1_ATTR_SHADE_MODE_GOURAUD )

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_GOURAUD );

}

else

if( materials[poly_material[curr_poly]].attr & MATV1_ATTR_SHADE_MODE_FASTPHONG )

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_FASTPHONG );

}

else

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_GOURAUD );

}

if( materials[poly_material[curr_poly]].attr & MATV1_ATTR_SHADE_MODE_TEXTURE )

{

SET_BIT( obj->plist[curr_poly].attr, POLY4DV1_ATTR_SHADE_MODE_TEXTURE );

}

num_materials += num_materials_object;

return ( 1 );

}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

业余封装3D软引擎

2014年8月26日星期二（DEMO8-9加载COB模型）的相关文章

c#-中级篇知识合集-part01

c 中级篇知识合集 part01 001 调试和错误处理 002 中断模式下的调试 003 错误处理异常处理 004 异常处理案例2 005 面向对象编程类 006 类的定义和声明 Program cs Vector3 cs Vehi
小鹏前自动驾驶AI负责人刘兰个川转投安克，研发具身智能

作者 StrongerTang 编辑自动驾驶Daily 点击下方卡片关注自动驾驶之心公众号 ADAS巨卷干货即可获取本文只做学术分享如有侵权联系删文据新智驾消息小鹏前自动驾驶AI负责人刘兰个川 Patrick 近期已加入
基于FPGA的混沌信号发生器设计与实现

提出基于FPGA设计混沌信号发生器的一种改进方法首先采用Euler算法将连续混沌系统转换为离散混沌系统其次基于IEEE 754单精度浮点数标准和模块化设计理念利用Quartus II软件采用VHDL和原理图相结合的方式设计混沌
Druid无效链接回收策略(源码分析)(mysql 8小时连接失效问题)

目录问题背景异常Communications link failure druid数据库连接池关键配置说明注意标红配置 druid数据库连接池超时连接回收源码分析第一种方式获取连接时校验第二种方式 Destroy 定时任务检查需

随机推荐

Python中关于序列化的讨论，以及dump、dumps和load、loads区别的对比

序列化序列化 pickle模块 json模块 shelve模块一 pickle模块1 pickle模块1 可以将对象转换为一种可以传输或存储的格式 2 pickle模块将任意一个python对象换成一个系统字节的操作过程叫做串行化对象 3
buck电路_简单电源（1）从电阻分压、稳压管、线性稳压器到BUCK变换器

电阻分压就是BUCK降压器最基本的原理惊讶吧如果有一个10V的电压要想得到5V的电压怎么办非常简单用二个阻值相同的电阻R1 R2串联起来从接地电阻R2上取电压就直接得到5V电压图1 串联电阻分压如果给这个电压加负载二个
element 中 el-date-picker 时间选择器时间跨度设置 7天

用 el date picker 实现日历的跨度七天
VS中“生成事件”的问题

转载自 http hi baidu com gisince item 7f0439ee610c94255a2d64b4 今天写了生成事件的处理如下从网上Down了一个例子运行时提示错误命令 copy F F 已退出返回值为 1 以
win10桌面突然显示未激活

1 以管理员身份打开cmd C Windows system32 cmd exe 2 输入sfc scannow命令自动修复系统文件 sfc scannow 3 修复完成后重启电脑
2023除夕倒计时~HTML代码
【超细节】Vue3组件事件怎么声明，defineEmits与emit

目录前言一基本语法 1 子组件触发 2 父组件监听二事件参数 1 传值 2 接收值三事件校验四注意事项前言组件事件是 Vue 组件之间进行通信的一种方式它允许一个组件触发一个自定义事件并且其他组件可以监听并响应这个
dw自动滚动图片_DW里怎么做图片自动播放

匿名用户 1级 2018 12 29 回答是做个简单的相册漂亮的Flash动画人人喜欢不过制作起来的确有一些技术难度你知道吗 Dreamweaver作为一个网页制作工具还可以创建好玩的Flash相册插入Flash元素运行Dre
从开源小白到 Apache Member ，阿里工程师的成长笔记

阿里妹导读 2019年5月4日 Apache 基金会官方 Blog 中宣布全球新增40位 Apache Member 阿里巴巴技术专家望陶成为其中之一全球共有771位 ASF Member 中国仅13位他从一个0基础的开源小白一路走来
是微服务不香了？淘宝为什么要放弃Spring Cloud 和 Dubbo？

都2021年了还没用过微服务吗中台架构还只是听说过 2020年的双十一天猫订单处理峰值达到58 3万笔秒 2020年的双十二数据量高达1200万 2021年的12306网站单日浏览峰值5000 亿次 2021年的一线互联网三高架
VSCode-Python传参数进行Debug

新建demo py import argparse def parse args description debug example parser argparse ArgumentParser description descriptio
openssl生成证书及利用mongoose实现简单RESTAPI_HTTPS_SERVER服务器测试

openssl生成证书及利用mongoose实现简单RESTAPI HTTPS SERVER服务器测试版本说明版本作者日期备注 0 1 loon 2019 4 1 初稿文章目录 openssl生成证书及利用mongoose实现简
兴趣部落老是显示无法连接服务器失败,qq兴趣部落为什么停运

很多人都有玩过qq兴趣部落但是最近官方宣布兴趣部落即将下线很多用户都不是很了解qq兴趣部落为什么停运针对这一点非凡小编给大家整理了相关的内容分享赶紧来了解一下吧 qq兴趣部落为什么停运一停运详情腾讯QQ群兴趣部落官网今日发布
Vue3的watchEffect的妙用，与watch的区别

前言在Vue3中引入了Composition API 其中的watchEffect 函数是一个非常强大和灵活的工具用于处理响应式数据的变化使得项目更加弹性和灵活它与watch有所不同本文将介绍watchEffect 的定义特点
一行一行写入csv

有时候数据量很大如果df to csv会占用很多内存因此一行一行写入 import csv out f open df save path w newline writer csv writer out f writer writero
Sent non-empty 'Sec-WebSocket-Protocol' header but no response was received

Sent non empty Sec WebSocket Protocol header but no response was received
c++访问私有（private)成员变量的常用方法

类的对象不能直接访问类声明的私有成员变量否则破坏了信息隐藏的目的在C 中为了防止某些数据成员或成员函数从外部被直接访问可以将它们声明为private 这样编译器会阻止任何来自外部非友元的直接访问私有成员变量的常用访问方法如下 1
mysql的sql性能分析器

author skate time 2012 02 17 mysql的sql性能分析器 MySQL 的SQL性能分析器主要用途是显示SQL执行的整个过程中各项资源的使用情况分析器可以更好的展示出不良SQL的性能问题所在 mysql sq
高德地图点标记及信息窗体的使用

项目背景要做一个数据大屏需要用到地图以及点标记 UI大致是这样我是结合vue使用的 vue调用高德地图有一个组件是vue amap 基于vue2 0和高德地图的我是后端开发 vue是才上手没有使用npm安装整个实现上可能走了一些
2014年8月26日星期二（DEMO8-9加载COB模型）

步骤 1读取文件开头第一行 2读取名称中心位置 X轴 Y轴和Z轴用来定义局部矩阵 3读取局部坐标到世界坐标的变换矩阵 4 读取World Vertices行并按照x y z顺序读取顶点列表 5 读取Texture Vertices行

2014年8月26日星期二（DEMO8-9加载COB模型）

2014年8月26日星期二（DEMO8-9加载COB模型） 的相关文章

随机推荐

热门标签

2014年8月26日星期二（DEMO8-9加载COB模型）的相关文章