nick/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2026-05-12 22:35:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Drop fully commented-out files

Browse Source 
Part of #5272
This commit is contained in:
Rémi Verschelde
2016-06-18 20:21:21 +02:00
parent 80727b6896
commit c3bf11d4d4
17 changed files with 8 additions and 2747 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/res_ptr.cpp
-90
View File
@@ -1,90 +0,0 @@
/*************************************************************************/
/* res_ptr.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#if 0
#include "ref_ptr.h"
#include "resource.h"
#include "stdio.h"
void RefPtr::operator=(const RefPtr& p_other) {
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
*ref = *ref_other;
}
bool RefPtr::operator==(const RefPtr& p_other) const {
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
return *ref == *ref_other;
}
RefPtr::RefPtr(const RefPtr& p_other) {
memnew_placement(&data[0],Ref<Resource>);
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
*ref = *ref_other;
}
bool RefPtr::is_null() const {
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
return ref->is_null();
}
RID RefPtr::get_rid() const {
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
if (ref->is_null())
return RID();
return (*ref)->get_rid();
}
RefPtr::RefPtr() {
ERR_FAIL_COND(sizeof(Ref<Resource>)>DATASIZE);
memnew_placement(&data[0],Ref<Resource>);
}
RefPtr::~RefPtr() {
Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
ref->~Ref<Resource>();
}
#endif
core/res_ptr.h
-63
View File
@@ -1,63 +0,0 @@
/*************************************************************************/
/* res_ptr.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef RES_PTR_H
#define RES_PTR_H
#if 0
/**
@author Juan Linietsky <reduzio@gmail.com>
* This class exists to workaround a limitation in C++ but keep the design OK.
* It's basically an opaque container of a Resource reference, so Variant can use it.
*/
#include "rid.h"
class ResBase;
class RefPtr {
friend class ResBase;
enum {
DATASIZE=sizeof(void*)*4
};
mutable char data[DATASIZE]; // too much probably, virtual class + pointer
public:
bool is_null() const;
void operator=(const RefPtr& p_other);
bool operator==(const RefPtr& p_other) const;
RID get_rid() const;
RefPtr(const RefPtr& p_other);
RefPtr();
~RefPtr();
};
#endif
#endif
scene/register_scene_types.cpp
+1 -23
View File
@@ -172,7 +172,6 @@
#include "scene/resources/world.h"
#include "scene/resources/world_2d.h"
#include "scene/resources/volume.h"
#include "scene/resources/sample_library.h"
#include "scene/resources/audio_stream.h"
@@ -476,31 +475,10 @@ void register_scene_types() {
AcceptDialog::set_swap_ok_cancel( GLOBAL_DEF("display/swap_ok_cancel",bool(OS::get_singleton()->get_swap_ok_cancel())) );
ObjectTypeDB::register_type<SamplePlayer>();
// ObjectTypeDB::register_type<StaticBody>();
// ObjectTypeDB::register_type<RigidBody>();
// ObjectTypeDB::register_type<CharacterBody>();
// ObjectTypeDB::register_type<BodyVolumeSphere>();
//ObjectTypeDB::register_type<BodyVolumeBox>();
//ObjectTypeDB::register_type<BodyVolumeCylinder>();
//ObjectTypeDB::register_type<BodyVolumeCapsule>();
//ObjectTypeDB::register_type<PhysicsJointPin>();
ObjectTypeDB::register_type<StreamPlayer>();
ObjectTypeDB::register_type<EventPlayer>();
/* disable types by default, only editors should enable them */
//ObjectTypeDB::set_type_enabled("BodyVolumeSphere",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeBox",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeCapsule",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeCylinder",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",false);
ObjectTypeDB::register_type<CanvasItemMaterial>();
ObjectTypeDB::register_virtual_type<CanvasItem>();
ObjectTypeDB::register_type<Node2D>();
@@ -621,11 +599,11 @@ void register_scene_types() {
OS::get_singleton()->yield(); //may take time to init
//ObjectTypeDB::register_type<Volume>();
ObjectTypeDB::register_type<Sample>();
ObjectTypeDB::register_type<SampleLibrary>();
ObjectTypeDB::register_virtual_type<AudioStream>();
ObjectTypeDB::register_virtual_type<AudioStreamPlayback>();
//TODO: Adapt to the new AudioStream API or drop (GH-3307)
// ObjectTypeDB::register_type<AudioStreamGibberish>();
ObjectTypeDB::register_virtual_type<VideoStream>();
scene/resources/gibberish_stream.cpp
+3
View File
@@ -29,6 +29,9 @@
#include "gibberish_stream.h"
#include "servers/audio_server.h"
//TODO: This class needs to be adapted to the new AudioStream API,
// or dropped if nobody cares about fixing it :) (GH-3307)
#if 0
int AudioStreamGibberish::get_channel_count() const {
scene/resources/gibberish_stream.h
+3
View File
@@ -29,6 +29,9 @@
#ifndef GIBBERISH_STREAM_H
#define GIBBERISH_STREAM_H
//TODO: This class needs to be adapted to the new AudioStream API,
// or dropped if nobody cares about fixing it :) (GH-3307)
#if 0
#include "scene/resources/audio_stream.h"
#include "scene/resources/sample_library.h"
scene/resources/volume.cpp
-211
View File
@@ -1,211 +0,0 @@
/*************************************************************************/
/* volume.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "volume.h"
#if 0
void Volume::_set(const String& p_name, const Variant& p_value) {
if (p_name.begins_with("shapes/")) {
int idx=p_name.get_slice("/",1).to_int()-1;
ERR_FAIL_COND( idx != get_shape_count() );
Dictionary shape = p_value;
ERR_FAIL_COND( !shape.has("type") || !shape.has("data"));
String type = shape["type"];
Variant data=shape["data"];
Transform transform;
if (shape.has("transform"))
transform=shape["transform"];
if (type=="plane")
add_shape(SHAPE_PLANE,data,transform);
else if (type=="sphere")
add_shape(SHAPE_SPHERE,data,transform);
else if (type=="box")
add_shape(SHAPE_BOX,data,transform);
else if (type=="cylinder")
add_shape(SHAPE_CYLINDER,data,transform);
else if (type=="capsule")
add_shape(SHAPE_CAPSULE,data,transform);
else if (type=="convex_polygon")
add_shape(SHAPE_CONVEX_POLYGON,data,transform);
else if (type=="concave_polygon")
add_shape(SHAPE_CONCAVE_POLYGON,data,transform);
else {
ERR_FAIL();
}
}
}
Variant Volume::_get(const String& p_name) const {
if (p_name.begins_with("shapes/")) {
int idx=p_name.get_slice("/",1).to_int()-1;
ERR_FAIL_INDEX_V( idx, get_shape_count(), Variant() );
Dictionary shape;
switch( get_shape_type(idx) ) {
case SHAPE_PLANE: shape["type"]="plane"; break;
case SHAPE_SPHERE: shape["type"]="sphere"; break;
case SHAPE_BOX: shape["type"]="box"; break;
case SHAPE_CYLINDER: shape["type"]="cylinder"; break;
case SHAPE_CAPSULE: shape["type"]="capsule"; break;
case SHAPE_CONVEX_POLYGON: shape["type"]="convex_polygon"; break;
case SHAPE_CONCAVE_POLYGON: shape["type"]="concave_polygon"; break;
}
shape["transform"]=get_shape_transform(idx);
shape["data"]=get_shape(idx);
return shape;
}
return Variant();
}
void Volume::_get_property_list( List<PropertyInfo> *p_list) const {
int count=get_shape_count();
for(int i=0;i<count;i++) {
p_list->push_back( PropertyInfo( Variant::DICTIONARY, "shapes/"+itos(i+1)) );
}
}
void Volume::add_shape(ShapeType p_shape_type, const Variant& p_data, const Transform& p_transform) {
PhysicsServer::get_singleton()->volume_add_shape(volume,(PhysicsServer::ShapeType)p_shape_type,p_data,p_transform);
_change_notify();
}
void Volume::add_plane_shape(const Plane& p_plane,const Transform& p_transform) {
add_shape(SHAPE_PLANE, p_plane, p_transform );
}
void Volume::add_sphere_shape(float p_radius,const Transform& p_transform) {
add_shape(SHAPE_SPHERE, p_radius, p_transform );
}
void Volume::add_box_shape(const Vector3& p_half_extents,const Transform& p_transform) {
add_shape(SHAPE_BOX, p_half_extents, p_transform );
}
void Volume::add_cylinder_shape(float p_radius, float p_height,const Transform& p_transform) {
Dictionary d;
d["radius"]=p_radius;
d["height"]=p_height;
add_shape(SHAPE_CYLINDER,d,p_transform);
}
void Volume::add_capsule_shape(float p_radius, float p_height,const Transform& p_transform) {
Dictionary d;
d["radius"]=p_radius;
d["height"]=p_height;
add_shape(SHAPE_CAPSULE,d,p_transform);
}
int Volume::get_shape_count() const {
return PhysicsServer::get_singleton()->volume_get_shape_count(volume);
}
Volume::ShapeType Volume::get_shape_type(int p_shape) const {
return (ShapeType)PhysicsServer::get_singleton()->volume_get_shape_type(volume,p_shape);
}
Transform Volume::get_shape_transform(int p_shape) const {
return PhysicsServer::get_singleton()->volume_get_shape_transform(volume,p_shape);
}
Variant Volume::get_shape(int p_shape) const {
return PhysicsServer::get_singleton()->volume_get_shape(volume,p_shape);
}
void Volume::_bind_methods() {
ObjectTypeDB::bind_method(_MD("add_shape","type","data","transform"),&Volume::add_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("add_plane_shape","plane","transform"),&Volume::add_plane_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("add_sphere_shape"),&Volume::add_sphere_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("add_box_shape","radius","transform"),&Volume::add_box_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("add_cylinder_shape","radius","height","transform"),&Volume::add_cylinder_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("add_capsule_shape","radius","height","transform"),&Volume::add_capsule_shape,DEFVAL( Transform() ));
ObjectTypeDB::bind_method(_MD("get_shape_count"),&Volume::get_shape_count);
ObjectTypeDB::bind_method(_MD("get_shape_type","shape_idx"),&Volume::get_shape_type);
ObjectTypeDB::bind_method(_MD("get_shape_transform","shape_idx"),&Volume::get_shape_transform);
ObjectTypeDB::bind_method(_MD("get_shape","shape_idx"),&Volume::get_shape);
BIND_CONSTANT( SHAPE_PLANE );
BIND_CONSTANT( SHAPE_SPHERE );
BIND_CONSTANT( SHAPE_BOX );
BIND_CONSTANT( SHAPE_CYLINDER );
BIND_CONSTANT( SHAPE_CAPSULE );
BIND_CONSTANT( SHAPE_CONVEX_POLYGON );
BIND_CONSTANT( SHAPE_CONCAVE_POLYGON );
}
RID Volume::get_rid() {
return volume;
}
Volume::Volume() {
volume= PhysicsServer::get_singleton()->volume_create();
}
Volume::~Volume() {
PhysicsServer::get_singleton()->free(volume);
}
#endif
scene/resources/volume.h
-86
View File
@@ -1,86 +0,0 @@
/*************************************************************************/
/* volume.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef VOLUME_H
#define VOLUME_H
#include "resource.h"
#if 0
#include "servers/physics_server.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
class Volume : public Resource {
OBJ_TYPE( Volume, Resource );
RID volume;
protected:
bool _set(const StringName& p_name, const Variant& p_value);
bool _get(const StringName& p_name,Variant &r_ret) const;
void _get_property_list( List<PropertyInfo> *p_list) const;
static void _bind_methods();
public:
enum ShapeType {
SHAPE_PLANE = PhysicsServer::SHAPE_PLANE, ///< plane:"plane"
SHAPE_SPHERE = PhysicsServer::SHAPE_SPHERE, ///< float:"radius"
SHAPE_BOX = PhysicsServer::SHAPE_BOX, ///< vec3:"extents"
SHAPE_CYLINDER = PhysicsServer::SHAPE_CYLINDER, ///< dict(float:"radius", float:"height"):cylinder
SHAPE_CAPSULE = PhysicsServer::SHAPE_CAPSULE, ///< dict(float:"radius", float:"height"):capsule
SHAPE_CONVEX_POLYGON = PhysicsServer::SHAPE_CONVEX_POLYGON, ///< array of planes:"planes"
SHAPE_CONCAVE_POLYGON = PhysicsServer::SHAPE_CONCAVE_POLYGON, ///< vector3 array:"triangles"
};
void add_shape(ShapeType p_shape_type, const Variant& p_data, const Transform& p_transform=Transform ());
void add_plane_shape(const Plane& p_plane,const Transform& p_transform);
void add_sphere_shape(float p_radius,const Transform& p_transform);
void add_box_shape(const Vector3& p_half_extents,const Transform& p_transform);
void add_cylinder_shape(float p_radius, float p_height,const Transform& p_transform);
void add_capsule_shape(float p_radius, float p_height,const Transform& p_transform);
int get_shape_count() const;
ShapeType get_shape_type(int p_shape) const;
Transform get_shape_transform(int p_shape) const;
Variant get_shape(int p_shape) const;
virtual RID get_rid();
Volume();
~Volume();
};
VARIANT_ENUM_CAST( Volume::ShapeType );
#endif
#endif
servers/physics/joints_sw.cpp
-450
View File
@@ -1,450 +0,0 @@
/*************************************************************************/
/* joints_sw.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "joints_sw.h"
#include "space_sw.h"
#if 0
//based on chipmunk joint constraints
/* Copyright (c) 2007 Scott Lembcke
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
static inline real_t k_scalar(Body2DSW *a,Body2DSW *b,const Vector2& rA, const Vector2& rB, const Vector2& n) {
real_t value=0;
{
value+=a->get_inv_mass();
real_t rcn = rA.cross(n);
value+=a->get_inv_inertia() * rcn * rcn;
}
if (b) {
value+=b->get_inv_mass();
real_t rcn = rB.cross(n);
value+=b->get_inv_inertia() * rcn * rcn;
}
return value;
}
bool PinJoint2DSW::setup(float p_step) {
Space2DSW *space = A->get_space();
ERR_FAIL_COND_V(!space,false;)
rA = A->get_transform().xform(anchor_A);
rB = B?B->get_transform().xform(anchor_B):anchor_B;
Vector2 delta = rB - rA;
rA-= A->get_transform().get_origin();
if (B)
rB-=B->get_transform().get_origin();
real_t jdist = delta.length();
correct=false;
if (jdist==0)
return false; // do not correct
correct=true;
n = delta / jdist;
// calculate mass normal
mass_normal = 1.0f/k_scalar(A, B, rA, rB, n);
// calculate bias velocity
//real_t maxBias = joint->constraint.maxBias;
bias = -(get_bias()==0?space->get_constraint_bias():get_bias())*(1.0/p_step)*(jdist-dist);
bias = CLAMP(bias, -get_max_bias(), +get_max_bias());
// compute max impulse
jn_max = get_max_force() * p_step;
// apply accumulated impulse
Vector2 j = n * jn_acc;
A->apply_impulse(rA,-j);
if (B)
B->apply_impulse(rB,j);
return true;
}
static inline Vector2
relative_velocity(Body2DSW *a, Body2DSW *b, Vector2 rA, Vector2 rB){
Vector2 sum = a->get_linear_velocity() -rA.tangent() * a->get_angular_velocity();
if (b)
return (b->get_linear_velocity() -rB.tangent() * b->get_angular_velocity()) - sum;
else
return -sum;
}
static inline real_t
normal_relative_velocity(Body2DSW *a, Body2DSW *b, Vector2 rA, Vector2 rB, Vector2 n){
return relative_velocity(a, b, rA, rB).dot(n);
}
void PinJoint2DSW::solve(float p_step){
if (!correct)
return;
Vector2 ln = n;
// compute relative velocity
real_t vrn = normal_relative_velocity(A,B, rA, rB, ln);
// compute normal impulse
real_t jn = (bias - vrn)*mass_normal;
real_t jnOld = jn_acc;
jn_acc = CLAMP(jnOld + jn,-jn_max,jn_max); //cpfclamp(jnOld + jn, -joint->jnMax, joint->jnMax);
jn = jn_acc - jnOld;
Vector2 j = jn*ln;
A->apply_impulse(rA,-j);
if (B)
B->apply_impulse(rB,j);
}
PinJoint2DSW::PinJoint2DSW(const Vector2& p_pos,Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,p_body_b?2:1) {
A=p_body_a;
B=p_body_b;
anchor_A = p_body_a->get_inv_transform().xform(p_pos);
anchor_B = p_body_b?p_body_b->get_inv_transform().xform(p_pos):p_pos;
jn_acc=0;
dist=0;
p_body_a->add_constraint(this,0);
if (p_body_b)
p_body_b->add_constraint(this,1);
}
PinJoint2DSW::~PinJoint2DSW() {
if (A)
A->remove_constraint(this);
if (B)
B->remove_constraint(this);
}
//////////////////////////////////////////////
//////////////////////////////////////////////
//////////////////////////////////////////////
static inline void
k_tensor(Body2DSW *a, Body2DSW *b, Vector2 r1, Vector2 r2, Vector2 *k1, Vector2 *k2)
{
// calculate mass matrix
// If I wasn't lazy and wrote a proper matrix class, this wouldn't be so gross...
real_t k11, k12, k21, k22;
real_t m_sum = a->get_inv_mass() + b->get_inv_mass();
// start with I*m_sum
k11 = m_sum; k12 = 0.0f;
k21 = 0.0f; k22 = m_sum;
// add the influence from r1
real_t a_i_inv = a->get_inv_inertia();
real_t r1xsq = r1.x * r1.x * a_i_inv;
real_t r1ysq = r1.y * r1.y * a_i_inv;
real_t r1nxy = -r1.x * r1.y * a_i_inv;
k11 += r1ysq; k12 += r1nxy;
k21 += r1nxy; k22 += r1xsq;
// add the influnce from r2
real_t b_i_inv = b->get_inv_inertia();
real_t r2xsq = r2.x * r2.x * b_i_inv;
real_t r2ysq = r2.y * r2.y * b_i_inv;
real_t r2nxy = -r2.x * r2.y * b_i_inv;
k11 += r2ysq; k12 += r2nxy;
k21 += r2nxy; k22 += r2xsq;
// invert
real_t determinant = k11*k22 - k12*k21;
ERR_FAIL_COND(determinant== 0.0);
real_t det_inv = 1.0f/determinant;
*k1 = Vector2( k22*det_inv, -k12*det_inv);
*k2 = Vector2(-k21*det_inv, k11*det_inv);
}
static _FORCE_INLINE_ Vector2
mult_k(const Vector2& vr, const Vector2 &k1, const Vector2 &k2)
{
return Vector2(vr.dot(k1), vr.dot(k2));
}
bool GrooveJoint2DSW::setup(float p_step) {
// calculate endpoints in worldspace
Vector2 ta = A->get_transform().xform(A_groove_1);
Vector2 tb = A->get_transform().xform(A_groove_2);
Space2DSW *space=A->get_space();
// calculate axis
Vector2 n = -(tb - ta).tangent().normalized();
real_t d = ta.dot(n);
xf_normal = n;
rB = B->get_transform().basis_xform(B_anchor);
// calculate tangential distance along the axis of rB
real_t td = (B->get_transform().get_origin() + rB).cross(n);
// calculate clamping factor and rB
if(td <= ta.cross(n)){
clamp = 1.0f;
rA = ta - A->get_transform().get_origin();
} else if(td >= tb.cross(n)){
clamp = -1.0f;
rA = tb - A->get_transform().get_origin();
} else {
clamp = 0.0f;
//joint->r1 = cpvsub(cpvadd(cpvmult(cpvperp(n), -td), cpvmult(n, d)), a->p);
rA = ((-n.tangent() * -td) + n*d) - A->get_transform().get_origin();
}
// Calculate mass tensor
k_tensor(A, B, rA, rB, &k1, &k2);
// compute max impulse
jn_max = get_max_force() * p_step;
// calculate bias velocity
// cpVect delta = cpvsub(cpvadd(b->p, joint->r2), cpvadd(a->p, joint->r1));
// joint->bias = cpvclamp(cpvmult(delta, -joint->constraint.biasCoef*dt_inv), joint->constraint.maxBias);
Vector2 delta = (B->get_transform().get_origin() +rB) - (A->get_transform().get_origin() + rA);
gbias=(delta*-(get_bias()==0?space->get_constraint_bias():get_bias())*(1.0/p_step)).clamped(get_max_bias());
// apply accumulated impulse
A->apply_impulse(rA,-jn_acc);
B->apply_impulse(rB,jn_acc);
correct=true;
return true;
}
void GrooveJoint2DSW::solve(float p_step){
// compute impulse
Vector2 vr = relative_velocity(A, B, rA,rB);
Vector2 j = mult_k(gbias-vr, k1, k2);
Vector2 jOld = jn_acc;
j+=jOld;
jn_acc = (((clamp * j.cross(xf_normal)) > 0) ? j : xf_normal.project(j)).clamped(jn_max);
j = jn_acc - jOld;
A->apply_impulse(rA,-j);
B->apply_impulse(rB,j);
}
GrooveJoint2DSW::GrooveJoint2DSW(const Vector2& p_a_groove1,const Vector2& p_a_groove2, const Vector2& p_b_anchor, Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,2) {
A=p_body_a;
B=p_body_b;
A_groove_1 = A->get_inv_transform().xform(p_a_groove1);
A_groove_2 = A->get_inv_transform().xform(p_a_groove2);
B_anchor=B->get_inv_transform().xform(p_b_anchor);
A_groove_normal = -(A_groove_2 - A_groove_1).normalized().tangent();
A->add_constraint(this,0);
B->add_constraint(this,1);
}
GrooveJoint2DSW::~GrooveJoint2DSW() {
A->remove_constraint(this);
B->remove_constraint(this);
}
//////////////////////////////////////////////
//////////////////////////////////////////////
//////////////////////////////////////////////
bool DampedSpringJoint2DSW::setup(float p_step) {
rA = A->get_transform().basis_xform(anchor_A);
rB = B->get_transform().basis_xform(anchor_B);
Vector2 delta = (B->get_transform().get_origin() + rB) - (A->get_transform().get_origin() + rA) ;
real_t dist = delta.length();
if (dist)
n=delta/dist;
else
n=Vector2();
real_t k = k_scalar(A, B, rA, rB, n);
n_mass = 1.0f/k;
target_vrn = 0.0f;
v_coef = 1.0f - Math::exp(-damping*(p_step)*k);
// apply spring force
real_t f_spring = (rest_length - dist) * stiffness;
Vector2 j = n * f_spring*(p_step);
A->apply_impulse(rA,-j);
B->apply_impulse(rB,j);
return true;
}
void DampedSpringJoint2DSW::solve(float p_step) {
// compute relative velocity
real_t vrn = normal_relative_velocity(A, B, rA, rB, n) - target_vrn;
// compute velocity loss from drag
// not 100% certain this is derived correctly, though it makes sense
real_t v_damp = -vrn*v_coef;
target_vrn = vrn + v_damp;
Vector2 j=n*v_damp*n_mass;
A->apply_impulse(rA,-j);
B->apply_impulse(rB,j);
}
void DampedSpringJoint2DSW::set_param(Physics2DServer::DampedStringParam p_param, real_t p_value) {
switch(p_param) {
case Physics2DServer::DAMPED_STRING_REST_LENGTH: {
rest_length=p_value;
} break;
case Physics2DServer::DAMPED_STRING_DAMPING: {
damping=p_value;
} break;
case Physics2DServer::DAMPED_STRING_STIFFNESS: {
stiffness=p_value;
} break;
}
}
real_t DampedSpringJoint2DSW::get_param(Physics2DServer::DampedStringParam p_param) const{
switch(p_param) {
case Physics2DServer::DAMPED_STRING_REST_LENGTH: {
return rest_length;
} break;
case Physics2DServer::DAMPED_STRING_DAMPING: {
return damping;
} break;
case Physics2DServer::DAMPED_STRING_STIFFNESS: {
return stiffness;
} break;
}
ERR_FAIL_V(0);
}
DampedSpringJoint2DSW::DampedSpringJoint2DSW(const Vector2& p_anchor_a,const Vector2& p_anchor_b, Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,2) {
A=p_body_a;
B=p_body_b;
anchor_A = A->get_inv_transform().xform(p_anchor_a);
anchor_B = B->get_inv_transform().xform(p_anchor_b);
rest_length=p_anchor_a.distance_to(p_anchor_b);
stiffness=20;
damping=1.5;
A->add_constraint(this,0);
B->add_constraint(this,1);
}
DampedSpringJoint2DSW::~DampedSpringJoint2DSW() {
A->remove_constraint(this);
B->remove_constraint(this);
}
#endif
servers/physics/joints_sw.h
+1 -120
View File
@@ -33,7 +33,6 @@
#include "body_sw.h"
class JointSW : public ConstraintSW {
@@ -45,122 +44,4 @@ public:
};
#if 0
class PinJointSW : public JointSW {
union {
struct {
BodySW *A;
BodySW *B;
};
BodySW *_arr[2];
};
Vector2 anchor_A;
Vector2 anchor_B;
real_t dist;
real_t jn_acc;
real_t jn_max;
real_t max_distance;
real_t mass_normal;
real_t bias;
Vector2 rA,rB;
Vector2 n; //normal
bool correct;
public:
virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_PIN; }
virtual bool setup(float p_step);
virtual void solve(float p_step);
PinJointSW(const Vector2& p_pos,BodySW* p_body_a,BodySW* p_body_b=NULL);
~PinJointSW();
};
class GrooveJointSW : public JointSW {
union {
struct {
BodySW *A;
BodySW *B;
};
BodySW *_arr[2];
};
Vector2 A_groove_1;
Vector2 A_groove_2;
Vector2 A_groove_normal;
Vector2 B_anchor;
Vector2 jn_acc;
Vector2 gbias;
real_t jn_max;
real_t clamp;
Vector2 xf_normal;
Vector2 rA,rB;
Vector2 k1,k2;
bool correct;
public:
virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_GROOVE; }
virtual bool setup(float p_step);
virtual void solve(float p_step);
GrooveJointSW(const Vector2& p_a_groove1,const Vector2& p_a_groove2, const Vector2& p_b_anchor, BodySW* p_body_a,BodySW* p_body_b);
~GrooveJointSW();
};
class DampedSpringJointSW : public JointSW {
union {
struct {
BodySW *A;
BodySW *B;
};
BodySW *_arr[2];
};
Vector2 anchor_A;
Vector2 anchor_B;
real_t rest_length;
real_t damping;
real_t stiffness;
Vector2 rA,rB;
Vector2 n;
real_t n_mass;
real_t target_vrn;
real_t v_coef;
public:
virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_DAMPED_SPRING; }
virtual bool setup(float p_step);
virtual void solve(float p_step);
void set_param(PhysicsServer::DampedStringParam p_param, real_t p_value);
real_t get_param(PhysicsServer::DampedStringParam p_param) const;
DampedSpringJointSW(const Vector2& p_anchor_a,const Vector2& p_anchor_b, BodySW* p_body_a,BodySW* p_body_b);
~DampedSpringJointSW();
};
#endif
#endif // JOINTS__SW_H
#endif // JOINTS_SW_H
servers/visual/shader_compiler.cpp
-30
View File
@@ -1,30 +0,0 @@
/*************************************************************************/
/* shader_compiler.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "shader_compiler.h"
servers/visual/shader_compiler.h
-142
View File
@@ -1,142 +0,0 @@
/*************************************************************************/
/* shader_compiler.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef SHADER_COMPILER_H
#define SHADER_COMPILER_H
#include "map.h"
#include "list.h"
#include "vector.h"
#if 0
class ShaderSyntax {
public:
enum DataType {
TYPE_BOOL,
TYPE_FLOAT,
TYPE_VEC3,
TYPE_TRANSFORM,
TYPE_TEXTURE
};
enum Operator {
OP_ASSIGN,
OP_ADD,
OP_SUB,
OP_MUL,
OP_DIV,
OP_NEG,
OP_CMP_EQ,
OP_CMP_NEQ,
OP_CMP_LEQ,
OP_CMP_GEQ,
OP_CMP_OR,
OP_CMP_AND,
OP_CALL
};
struct Node {
enum Type {
TYPE_PROGRAM,
TYPE_FUNCTION,
TYPE_BLOCK,
TYPE_VARIABLE,
TYPE_OPERATOR,
TYPE_IF,
};
Node * parent;
Type type;
virtual ~Node() {}
};
struct OperatorNode : public Node {
Operator op;
Vector<Node*> arguments;
OperatorNode() { type=TYPE_OPERATOR; }
};
struct VariableNode : public Node {
StringName variable;
VariableNode() { type=TYPE_VARIABLE; }
};
struct BlockNode : public Node {
Map<StringName,DataType> variables;
List<Node*> subnodes;
BlockNode() { type=TYPE_BLOCK; }
};
struct ConditionalNode : public Node {
Node *test;
Node *do_if;
Node *do_else;
ConditionalNode() { type=TYPE_CONDITIONAL; }
};
struct FunctionNode : public Node {
struct Argument {
StringName name;
DataType type;
};
Vector<Argument> arguments;
Node *body;
FunctionNode() { type=TYPE_FUNCTION; }
};
struct ProgramNode : public Node {
Vector<FunctionNode*> functions;
Node *body;
ProgramNode() { type=TYPE_PROGRAM; }
};
ShaderCompiler();
};
#endif // SHADER_COMPILER_H
#endif
servers/visual/shader_graph.cpp
-455
View File
@@ -1,455 +0,0 @@
/*************************************************************************/
/* shader_graph.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "shader_graph.h"
#if 0
struct _ConnectionKey {
int node;
int slot;
_FORCE_INLINE_ _ConnectionKey(int p_node=0,int p_slot=0) { node=p_node; slot=p_slot; }
_FORCE_INLINE_ bool operator<(const _ConnectionKey& p_other) const {
if (node<p_other.node)
return true;
else if (node>p_other.node)
return false;
else
return slot<p_other.slot;
}
};
Error ShaderGraph::generate(ShaderCodeGenerator * p_generator) const {
Map<int,Node>::Element *E = node_map.front();
int i=0;
while(E) {
E->get().order=i++;
E->get().out_valid=false;
E->get().in_valid=false;
E=E->next();
}
int worst_case=connections.size() * connections.size(); // worst bubble case
int iterations=0;
int swaps;
do {
swaps=0;
const List<Connection>::Element *E=connections.front();
while(E) {
const Connection &c = E->get();
const Node *src = &node_map[c.src_id];
const Node *dst = &node_map[c.dst_id];
if (src->order > dst->order) {
SWAP(src->order, dst->order);
swaps++;
}
E=E->next();
}
iterations++;
} while (iterations<=worst_case && swaps>0);
ERR_FAIL_COND_V( swaps != 0 , ERR_CYCLIC_LINK );
//node array
Vector<const Node*> nodes;
nodes.resize(node_map.size());
E = node_map.front();
while(E) {
ERR_FAIL_INDEX_V( E->get().order, nodes.size(), ERR_BUG);
nodes[E->get().order]=&E->get();
E=E->next();
}
//connection set
Map<_ConnectionKey,int> in_connection_map;
Map<_ConnectionKey,List<int> > out_connection_map;
Map<_ConnectionKey,int> in_node_map;
Map<_ConnectionKey,List<int> > out_node_map;
const List<Connection>::Element *CE=connections.front();
i=0;
while(CE) {
const Connection &c = CE->get();
_ConnectionKey in_k;
in_k.node=node_map[c.dst_id].order;
in_k.slot=c.dst_slot;
in_connection_map[in_k]=i;
in_node_map[in_k]=node_map[c.src_id].order;
_ConnectionKey out_k;
out_k.node=node_map[c.src_id].order;
out_k.slot=c.src_slot;
if (!out_connection_map.has(out_k))
out_connection_map[out_k]=List<int>();
out_connection_map[out_k].push_back(i);
if(!out_node_map.has(out_k))
out_node_map[out_k]=List<int>();
out_node_map[out_k].push_back(node_map[c.dst_id].order);
i++;
CE=CE->next();
}
// validate nodes if they are connected to an output
for(int i=nodes.size()-1;i>=0;i--) {
if (VisualServer::shader_get_output_count(nodes[i]->type)==0) {
// an actual graph output
_ConnectionKey in_k;
in_k.node=nodes[i]->order;
in_k.slot=0;
if (in_node_map.has(in_k)) {
nodes[i]->out_valid=true;
}
} else {
// regular node
bool valid=false;
for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
_ConnectionKey key(nodes[i]->order,j);
if (out_node_map.has(key)) {
for(List<int>::Element *CE=out_node_map[key].front();CE;CE=CE->next()) {
int to_node=CE->get();
ERR_CONTINUE(to_node<0 || to_node >=nodes.size());
if (nodes[to_node]->out_valid) {
valid=true;
break;
}
}
}
if (valid)
break;
}
nodes[i]->out_valid=valid;
}
}
// validate nodes if they are connected to an input
for(int i=0;i<nodes.size();i++) {
if (VisualServer::shader_get_input_count(nodes[i]->type)==0) {
// an actual graph input
int out_count=VisualServer::shader_get_output_count(nodes[i]->type);
for(int j=0;j<out_count;j++) {
_ConnectionKey out_k;
out_k.node=nodes[i]->order;
out_k.slot=j;
if (out_node_map.has(out_k)) {
nodes[i]->in_valid=true;
break;
}
}
} else {
// regular node
// this is very important.. for a node to be valid, all its inputs need to be valid
bool valid=true;
for(int j=0;j<VS::shader_get_input_count(nodes[i]->type);j++) {
bool in_valid=false;
_ConnectionKey key(nodes[i]->order,j);
if (in_node_map.has(key)) {
int from_node=in_node_map[key];
ERR_CONTINUE(from_node<0 || from_node>=nodes.size());
if (nodes[from_node]->in_valid)
in_valid=true;
}
if (!in_valid) {
valid=false;
break;
}
}
nodes[i]->in_valid=valid;
}
}
// write code
p_generator->begin();
for(int i=0;i<nodes.size();i++) {
if (!nodes[i]->out_valid || !nodes[i]->in_valid) // valid in both ways
continue; // skip node
Vector<int> in_indices;
in_indices.resize(VS::shader_get_input_count(nodes[i]->type));
Vector<int> out_indices;
Vector<int> out_slot_indices;
for(int j=0;j<in_indices.size();j++) {
_ConnectionKey key(nodes[i]->order,j);
if (in_connection_map.has(key))
in_indices[j]=in_connection_map[key];
else
in_indices[j]=-1;
}
for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
_ConnectionKey key(nodes[i]->order,j);
if (out_connection_map.has(key)) {
for(List<int>::Element *CE=out_connection_map[key].front();CE;CE=CE->next()) {
out_indices.push_back(CE->get());
out_slot_indices.push_back(j);
}
}
}
Error err = p_generator->add_node(nodes[i]->type,i,nodes[i]->id,nodes[i]->param,in_indices,out_indices,out_slot_indices);
ERR_FAIL_COND_V( err, err );
}
p_generator->end();
return OK;
}
void ShaderGraph::node_add(VS::ShaderNodeType p_type,int p_id) {
ERR_FAIL_COND( node_map.has(p_id ) );
ERR_FAIL_INDEX( p_type, VS::NODE_TYPE_MAX );
Node node;
node.type=p_type;
node.id=p_id;
node.x=0;
node.y=0;
node_map[p_id]=node;
}
void ShaderGraph::node_set_pos(int p_id, int p_x,int p_y) {
ERR_FAIL_COND(!node_map.has(p_id));
node_map[p_id].x=p_x;
node_map[p_id].y=p_y;
}
int ShaderGraph::node_get_pos_x(int p_id) const {
ERR_FAIL_COND_V(!node_map.has(p_id),-1);
return node_map[p_id].x;
}
int ShaderGraph::node_get_pos_y(int p_id) const {
ERR_FAIL_COND_V(!node_map.has(p_id),-1);
return node_map[p_id].y;
}
void ShaderGraph::node_remove(int p_id) {
ERR_FAIL_COND(!node_map.has(p_id));
//erase connections associated with node
List<Connection>::Element *N,*E=connections.front();
while(E) {
N=E->next();
const Connection &c = E->get();
if (c.src_id==p_id || c.dst_id==p_id) {
connections.erase(E);
}
E=N;
}
node_map.erase(p_id);
}
void ShaderGraph::node_change_type(int p_id, VS::ShaderNodeType p_type) {
ERR_FAIL_COND(!node_map.has(p_id));
node_map[p_id].type=p_type;
node_map[p_id].param=Variant();
}
void ShaderGraph::node_set_param(int p_id, const Variant& p_value) {
ERR_FAIL_COND(!node_map.has(p_id));
node_map[p_id].param=p_value;
}
void ShaderGraph::get_node_list(List<int> *p_node_list) const {
Map<int,Node>::Element *E = node_map.front();
while(E) {
p_node_list->push_back(E->key());
E=E->next();
}
}
VS::ShaderNodeType ShaderGraph::node_get_type(int p_id) const {
ERR_FAIL_COND_V(!node_map.has(p_id),VS::NODE_TYPE_MAX);
return node_map[p_id].type;
}
Variant ShaderGraph::node_get_param(int p_id) const {
ERR_FAIL_COND_V(!node_map.has(p_id),Variant());
return node_map[p_id].param;
}
Error ShaderGraph::connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
ERR_FAIL_COND_V(p_src_id==p_dst_id, ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(!node_map.has(p_src_id), ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(!node_map.has(p_dst_id), ERR_INVALID_PARAMETER);
VisualServer::ShaderNodeType type_src=node_map[p_src_id].type;
VisualServer::ShaderNodeType type_dst=node_map[p_dst_id].type;
ERR_FAIL_INDEX_V( p_src_slot, VisualServer::shader_get_output_count(type_src), ERR_INVALID_PARAMETER );
ERR_FAIL_INDEX_V( p_dst_slot, VisualServer::shader_get_input_count(type_dst), ERR_INVALID_PARAMETER );
ERR_FAIL_COND_V(VisualServer::shader_is_output_vector(type_src,p_src_slot) != VisualServer::shader_is_input_vector(type_dst,p_dst_slot), ERR_INVALID_PARAMETER );
List<Connection>::Element *E=connections.front();
while(E) {
const Connection &c = E->get();
ERR_FAIL_COND_V(c.dst_slot==p_dst_slot && c.dst_id == p_dst_id, ERR_ALREADY_EXISTS);
E=E->next();
}
Connection c;
c.src_slot=p_src_slot;
c.src_id=p_src_id;
c.dst_slot=p_dst_slot;
c.dst_id=p_dst_id;
connections.push_back(c);
return OK;
}
bool ShaderGraph::is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const {
const List<Connection>::Element *E=connections.front();
while(E) {
const Connection &c = E->get();
if (c.dst_slot==p_dst_slot && c.dst_id == p_dst_id && c.src_slot==p_src_slot && c.src_id == p_src_id)
return true;
E=E->next();
}
return false;
}
void ShaderGraph::disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
List<Connection>::Element *N,*E=connections.front();
while(E) {
N=E->next();
const Connection &c = E->get();
if (c.src_slot==p_src_slot && c.src_id==p_src_id && c.dst_slot==p_dst_slot && c.dst_id == p_dst_id) {
connections.erase(E);
}
E=N;
}
}
void ShaderGraph::clear() {
connections.clear();
node_map.clear();
}
List<ShaderGraph::Connection> ShaderGraph::get_connection_list() const {
return connections;
}
ShaderGraph::ShaderGraph() {
}
ShaderGraph::~ShaderGraph() {
}
#endif
servers/visual/shader_graph.h
-109
View File
@@ -1,109 +0,0 @@
/*************************************************************************/
/* shader_graph.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#if 0
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#include "servers/visual_server.h"
#include "map.h"
class ShaderCodeGenerator {
public:
virtual void begin()=0;
virtual Error add_node(VS::ShaderNodeType p_type,int p_node_pos,int p_id,const Variant& p_param,const Vector<int>& p_in_connections,const Vector<int>& p_out_connections,const Vector<int>& p_out_connection_outputs)=0;
virtual void end()=0;
virtual ~ShaderCodeGenerator() {}
};
class ShaderGraph {
public:
struct Connection {
int src_id;
int src_slot;
int dst_id;
int dst_slot;
};
private:
struct Node {
int16_t x,y;
VS::ShaderNodeType type;
Variant param;
int id;
mutable int order; // used for sorting
mutable bool out_valid;
mutable bool in_valid;
};
Map<int,Node> node_map;
List<Connection> connections;
public:
Error generate(ShaderCodeGenerator * p_generator) const;
void node_add(VS::ShaderNodeType p_type,int p_id);
void node_remove(int p_id);
void node_change_type(int p_id, VS::ShaderNodeType p_type);
void node_set_param(int p_id, const Variant& p_value);
void node_set_pos(int p_id, int p_x,int p_y);
int node_get_pos_x(int p_id) const;
int node_get_pos_y(int p_id) const;
void get_node_list(List<int> *p_node_list) const;
void get_sorted_node_list(List<int> *p_node_list) const;
VS::ShaderNodeType node_get_type(int p_id) const;
Variant node_get_param(int p_id) const;
Error connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);
bool is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const;
void disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);
void clear();
List<Connection> get_connection_list() const;
ShaderGraph();
~ShaderGraph();
};
#endif
tools/editor/editor_node.cpp
-1
View File
@@ -5224,7 +5224,6 @@ EditorNode::EditorNode() {
ObjectTypeDB::set_type_enabled("CollisionShape",true);
ObjectTypeDB::set_type_enabled("CollisionShape2D",true);
ObjectTypeDB::set_type_enabled("CollisionPolygon2D",true);
//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",true);
Control *theme_base = memnew( Control );
add_child(theme_base);
tools/editor/plugins/control_editor_plugin.cpp
-825
View File
File diff suppressed because it is too large Load Diff
tools/editor/plugins/control_editor_plugin.h
-141
View File
@@ -1,141 +0,0 @@
/*************************************************************************/
/* control_editor_plugin.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef CONTROL_EDITOR_PLUGIN_H
#define CONTROL_EDITOR_PLUGIN_H
#include "tools/editor/editor_plugin.h"
#include "tools/editor/editor_node.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
#if 0
class ControlEditor : public Control {
OBJ_TYPE(ControlEditor, Control );
EditorNode *editor;
enum {
SNAP_USE,
SNAP_CONFIGURE
};
enum DragType {
DRAG_NONE,
DRAG_LEFT,
DRAG_TOP_LEFT,
DRAG_TOP,
DRAG_TOP_RIGHT,
DRAG_RIGHT,
DRAG_BOTTOM_RIGHT,
DRAG_BOTTOM,
DRAG_BOTTOM_LEFT,
DRAG_ALL
};
HScrollBar *h_scroll;
VScrollBar *v_scroll;
Matrix32 transform;
float zoom;
Control *current_window;
PopupMenu *popup;
DragType drag;
Point2 drag_from;
struct EditInfo {
Point2 drag_pos;
Point2 drag_size;
Point2 drag_limit;
Rect2 last_rect;
};
typedef Map<Control*,EditInfo> ControlMap;
ControlMap controls;
int handle_len;
Control* _select_control_at_pos(const Point2& p_pos,Node* p_node);
ConfirmationDialog *snap_dialog;
LineEdit *snap_val;
void _add_control(Control *p_control,const EditInfo& p_info);
void _remove_control(Control *p_control);
void _clear_controls();
void _visibility_changed(ObjectID p_control);
void _key_move(const Vector2& p_dir, bool p_snap);
Point2i snapify(const Point2i& p_pos) const;
void _popup_callback(int p_op);
bool updating_scroll;
void _update_scroll(float);
void _update_scrollbars();
UndoRedo *undo_redo;
void _find_controls_span(Node *p_node, Rect2& r_rect);
protected:
void _notification(int p_what);
void _input_event(InputEvent p_event);
void _node_removed(Node *p_node);
static void _bind_methods();
public:
bool get_remove_list(List<Node*> *p_list);
void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; }
void edit(Control *p_control);
ControlEditor(EditorNode *p_editor);
};
class ControlEditorPlugin : public EditorPlugin {
OBJ_TYPE( ControlEditorPlugin, EditorPlugin );
ControlEditor *control_editor;
EditorNode *editor;
public:
virtual String get_name() const { return "GUI"; }
bool has_main_screen() const { return true; }
virtual void edit(Object *p_object);
virtual bool handles(Object *p_object) const;
virtual void make_visible(bool p_visible);
virtual bool get_remove_list(List<Node*> *p_list) { return control_editor->get_remove_list(p_list); }
ControlEditorPlugin(EditorNode *p_node);
~ControlEditorPlugin();
};
#endif
#endif
tools/editor/plugins/shader_graph_editor_plugin.h
-1
View File
@@ -33,7 +33,6 @@
#include "tools/editor/editor_plugin.h"
#include "tools/editor/editor_node.h"
#include "scene/resources/shader.h"
#include "servers/visual/shader_graph.h"
#include "scene/gui/tree.h"
#include "scene/gui/button.h"
#include "scene/gui/graph_edit.h"